Building IntegrityLens: Angular + AI Biometric Verification with Firebase and OpenAI (12k+ Interviews, Real‑Time, Secure)

The Challenge: Secure, Real‑Time Candidate Screening at Scale (12k+ Sessions)

Before IntegrityLens, hiring teams manually verified identity—a slow, error-prone process with inconsistent outcomes. We needed to automate liveness + face match, keep AI assist safe, and preserve a great UX. The bar: zero production outages while scaling past 10k sessions.

Architecture: Angular 20+, Firebase, and OpenAI—A Safe Path to Real‑Time Biometrics

This stack balances speed, cost, and safety. Signals/SignalStore make the UI predictable. Firebase handles real-time and authZ. OpenAI runs behind guardrails for summaries and anomaly classification—never as a decision-maker.

Implementation Walkthrough: Signals + SignalStore Drive the Verification Flow

Here’s a trimmed version of the SignalStore that orchestrates the end-to-end verification flow.

Code: SignalStore for Verification Flow (Angular 20)

import { signal, computed, inject } from '@angular/core';
import { SignalStore, patchState } from '@ngrx/signals';
import { HttpClient } from '@angular/common/http';
import { randomJitterMs } from './util/backoff';
import { remoteConfigFlag } from './flags';

export type Step = 'idle'|'capture'|'liveness'|'match'|'complete'|'error';
interface VerificationState {
  step: Step;
  attempt: number;
  photoUrl?: string;
  livenessScore?: number;
  matchScore?: number;
  error?: string;
}

export class VerificationStore extends SignalStore<VerificationState> {
  private http = inject(HttpClient);
  private provider = remoteConfigFlag('biometrics.provider'); // 'providerA' | 'providerB'

  step = signal<Step>('idle');
  attempt = signal(0);
  photoUrl = signal<string | undefined>(undefined);
  livenessScore = signal<number | undefined>(undefined);
  matchScore = signal<number | undefined>(undefined);
  error = signal<string | undefined>(undefined);

  canContinue = computed(() => this.step() === 'capture' ? !!this.photoUrl() : true);

  async startCapture(blob: Blob) {
    patchState(this, { step: 'capture', error: undefined });
    const url = await this.upload(blob);
    patchState(this, { photoUrl: url });
    await this.runLiveness(url);
  }

  private async upload(blob: Blob) {
    // Signed URL from Cloud Function; never expose buckets directly
    const { url } = await this.http.post<{ url: string }>(`/api/signed-upload`, {}).toPromise();
    await fetch(url, { method: 'PUT', body: blob });
    return url.split('?')[0];
  }

  private async runLiveness(url: string) {
    patchState(this, { step: 'liveness' });
    await this.withRetry(async () => {
      const res = await this.http.post<{ score: number }>(`/api/liveness`, { url, provider: this.provider() }).toPromise();
      patchState(this, { livenessScore: res!.score });
    });
    await this.runMatch(url);
  }

  private async runMatch(url: string) {
    patchState(this, { step: 'match' });
    await this.withRetry(async () => {
      const res = await this.http.post<{ score: number }>(`/api/face-match`, { url, provider: this.provider() }).toPromise();
      patchState(this, { matchScore: res!.score, step: 'complete' });
    });
  }

  private async withRetry<T>(fn: () => Promise<T>) {
    for (let i = 0; i < 3; i++) {
      try { return await fn(); }
      catch (e: any) {
        patchState(this, { attempt: this.attempt() + 1, error: e?.message ?? 'Retrying...' });
        await new Promise(r => setTimeout(r, randomJitterMs(250 * Math.pow(2, i))));
      }
    }
    patchState(this, { step: 'error', error: 'Please try again later.' });
    throw new Error('Verification failed after retries');
  }
}

Secure Data Flow: Firestore/Storage Rules and Cloud Functions

# firestore.rules
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    function isTenant(user, tenantId) { return request.auth.token.tenant_id == tenantId; }
    function hasRole(role) { return role in request.auth.token.roles; }

    match /tenants/{tenantId}/candidates/{candidateId}/verifications/{verificationId} {
      allow read: if isTenant(request.auth, tenantId) && hasRole('recruiter');
      allow create: if isTenant(request.auth, tenantId) && request.auth.uid == candidateId;
      allow update, delete: if false; // immutable verification records
    }
  }
}

// functions/src/biometrics.ts
import * as functions from 'firebase-functions';
import fetch from 'node-fetch';
import crypto from 'crypto';

export const faceMatch = functions.https.onCall(async (data, context) => {
  const { url, provider } = data;
  const tenantId = context.auth?.token.tenant_id;
  if (!tenantId) throw new functions.https.HttpsError('unauthenticated', 'No tenant');

  const payload = JSON.stringify({ url, tenantId });
  const sig = crypto.createHmac('sha256', process.env.PROVIDER_SECRET!).update(payload).digest('hex');

  const res = await fetch(`https://api.${provider}.com/face-match`, {
    method: 'POST', headers: { 'x-signature': sig, 'content-type': 'application/json' }, body: payload
  });
  if (!res.ok) throw new functions.https.HttpsError('unavailable', 'Provider error');
  const { score } = await res.json();
  return { score };
});

AI Assistance with Guardrails: OpenAI Structured Outputs and Risk Scoring

// functions/src/summary.ts
import OpenAI from 'openai';
import * as functions from 'firebase-functions';

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export const summarizeInterview = functions.https.onCall(async (data, context) => {
  const { transcript, riskSignals } = data; // transcript already redacted server-side
  const schema = {
    type: 'object',
    properties: {
      summary: { type: 'string' },
      concerns: { type: 'array', items: { type: 'string' } },
      score: { type: 'number', minimum: 0, maximum: 1 }
    },
    required: ['summary','score']
  } as const;

  const response = await client.responses.create({
    model: 'gpt-4o-mini',
    input: [{ role: 'system', content: 'Return JSON matching the provided schema only.' },
            { role: 'user', content: `Transcript: ${transcript}\nSignals: ${JSON.stringify(riskSignals)}` }],
    response_format: { type: 'json_schema', json_schema: { name: 'InterviewSummary', schema } },
    max_output_tokens: 400
  });

  const result = JSON.parse(response.output_text!);
  return { summary: result.summary, concerns: result.concerns ?? [], score: result.score };
});

Observability, Performance, and UX Metrics Executives Care About

Results aren’t opinions. We measured P50/P95 verification times, false positives/negatives, and abandonment by device and network. Issues surface in dashboards before support tickets do.

When to Hire an Angular Developer for Biometric Verification or AI Projects

I work as a remote Angular consultant or contract Angular developer. If you need to hire an Angular developer with Fortune 100 experience across aviation, telecom, and insurance, let’s talk about your roadmap.

Results: Faster Verifications, Fewer False Positives, Zero Outages

These are the numbers hiring managers and directors care about: speed, accuracy, and reliability. IntegrityLens delivered on all three.

What to Build Next: Roadmap and Re‑usable Assets

For AI-heavy or device-integrated apps—kiosks, telematics dashboards, and interview platforms—these patterns repeat. They’re proven across airports, broadcast scheduling, and IoT device portals I’ve shipped.

Concise Takeaways and Next Steps

• Signals + SignalStore keep biometric flows deterministic and testable.

• Firebase provides real-time UX with enforceable security boundaries.

• AI is helpful when boxed in with typed schemas, privacy, and circuit breakers.

• Ship with guardrails: CI budgets, canaries, and feature flags.

If you need an Angular expert to integrate AI or biometrics—or to stabilize a chaotic codebase—reach out. I can review your repo this week and propose a phased plan.