An invitation to engineers

Help us prove private reciprocal matching can work at scale

We are building a system that can understand two people without exposing either one, test whether a connection works in both directions, and stop when permission or evidence runs out. This page shows the architecture we have chosen, the workload we can bound, and the production proof we still need engineers to earn.

Architecture specifiedWorking simulationScale proof still aheadSee the matching path

The questions that decide the system

Three problems decide whether this system deserves to exist.

These are not edge cases to solve later. They determine whether the system can be useful without becoming careless, invasive, or impossible to operate.

  1. 01

    Claims and evidence

    How do we handle information that may be wrong, stale, contradictory, or misleading?

    Our architecture answer

    We do not build a lie detector.

    We preserve who said what, when, for which purpose, from which source, with which confidence basis, and through which version lineage. Assertions, model proposals, bounded verifications, corrections, and contradictions remain different states. When a disputed fact matters, the system asks for the minimum clarification or stronger evidence it needs.

    The boundary
    No honesty, trustworthiness, or universal truth score follows a person. Contradictions may reflect change, context, uncertainty, or a bad extraction. Safety and fraud concerns go to a dedicated, accountable process; insufficient evidence produces qualification, pause, or abstention.
    Proof still required
    Versioned evaluation cases must measure source coverage, contradiction handling, correction propagation, unsupported-claim refusal, and abstention without turning model confidence into truth.
  2. 02

    Bounded retrieval

    How can matching stay bounded across billions of stored and derived records?

    Our architecture answer

    Never compare everyone with everyone.

    Offline, purpose-scoped projections divide the corpus by lane, role, geography, time, policy, and model version. Hybrid retrieval searches only compatible partitions and returns a bounded union. PostgreSQL then rechecks current consent, blocks, expiry, and hard constraints before reciprocal scoring reduces the set again.

    The boundary
    Indexes and vectors help recall; they never own identity, permission, or eligibility. The online path stops at 1,000 retrieved intentions, 200 policy-eligible candidates, 50 reciprocal pairs, and 3–10 deep reviews—often producing no proposal.
    Proof still required
    The specified target corpus remains 100 million active intentions. Billions of stored and derived records describe an architecture pressure, not proven capacity. A versioned synthetic benchmark must prove recall, skew, freshness, p50/p95/p99 latency, resource cost, invalidation, and recovery at the stated candidate budgets.
  3. 03

    LLM infrastructure

    How do we run models we can actually depend on?

    Our architecture answer

    Put models inside a governed system.

    NestJS services authorize each task. Mastra orchestrates approved model calls through typed AI SDK boundaries using privacy-minimized context plus versioned prompts and models. Schemas reject malformed output, Temporal owns durable retries and reconciliation, and PostgreSQL keeps canonical state. Langfuse is the approved target for privacy-minimized traces, evaluations, versions, latency, and cost evidence.

    The boundary
    A model may propose, classify, or abstain. It cannot turn its own output into truth, consent, policy, or a connection. If no safe model route meets the floor, the system returns an explicit unavailable or abstained result instead of fabricating success.
    Proof still required
    Every meaningful model, prompt, context, retrieval, provider, or orchestration change needs versioned evaluations for schema validity, groundedness, leakage, refusal, retries, latency, cost, regressions, rollback, and kill-switch behavior.

What we are building with

A practical stack for a difficult trust problem

We chose familiar tools with clear jobs so the hard work stays visible. Some are already in use. Others are approved targets that still need to be integrated and proven.

Product interfaces

  • In use

    React

    Web interface runtime

  • In use

    Vite

    Web build system

  • In use

    Expo

    Native mobile application

  • In use

    React Native

    Native interface runtime and StyleSheet.create styling

  • In use

    TanStack

    Router and server state

  • In use

    Three.js

    Spatial matching visualization

  • In use

    Tailwind CSS

    Application styling

  • In use

    TypeScript

    Typed application source

  • In use

    Paraglide JS

    Typed localization

API and contracts

  • In use

    Node.js

    Server JavaScript runtime

  • In use

    NestJS

    HTTP and application composition

  • In use

    Fastify

    NestJS HTTP server adapter

  • In use

    Zod

    Boundary validation

  • In use

    OpenAPI

    Public API contract

  • In use

    Scalar

    Interactive API reference

  • In use

    Fern

    Generated TypeScript client

  • In use

    Better Auth

    Account and session authority

Intelligence and durable work

  • In use

    Mastra

    Service-controlled AI orchestration

  • In use

    AI SDK

    Typed model and streaming protocol

  • In use

    Temporal

    Durable background workflows

Data and machine learning

  • In use

    PostgreSQL

    Canonical product and consent truth

  • In use

    TypeORM

    Persistence mapping and migrations

  • Approved target

    dbt

    Analytics transformations and data quality

  • Approved target

    Apache Iceberg

    Open analytical table format

  • Approved target

    Amazon SageMaker

    Managed model training and evaluation

Cloud and infrastructure

  • In use

    Cloudflare

    Edge, storage, and static delivery cloud

  • Approved target

    AWS

    Training and analytical workload cloud

  • In use

    Docker Compose

    Versioned service topology

  • In use

    Dokploy

    VPS deployment controller

  • Approved target

    Terraform

    Versioned infrastructure provisioning

  • In use

    Cloudflare Pages

    Static web deployment

  • In use

    Cloudflare R2

    Protected object storage

Observability and analytics

  • In use

    Consola

    Structured diagnostic logging

  • Approved target

    Langfuse

    AI traces, evaluations, versions, latency, and cost evidence

  • Approved target

    PostHog

    Consent-gated product behavior analytics

  • Approved target

    Sentry

    Scrubbed application crash diagnostics

Verification and quality

  • In use

    Vitest

    Backend and contract behavior tests

  • In use

    Testcontainers

    Disposable PostgreSQL integration environments

  • In use

    Playwright CLI

    Human-observed browser walkthroughs

  • In use

    Maestro

    Native mobile end-to-end verification

  • In use

    Oxc

    Formatting and static linting

Delivery and project management

  • Operating tool

    GitHub

    Source collaboration and review

  • Operating tool

    GitHub Actions

    Automated verification and deployment evidence

  • Operating tool

    Composio

    Authorized external-tool connector

  • In use

    pnpm

    Package management

  • In use

    Turborepo

    Workspace task orchestration

Reciprocal matching

The hard part is not finding similarity. It is protecting both people while testing mutual fit.

Matching pipeline stages

Make each decision smaller, bounded, and inspectable

  1. 01

    100M target corpus

  2. 02

    ≤1,000 retrieved

  3. 03

    ≤200 policy eligible

  4. 04

    ≤50 reciprocal pairs

  5. 05

    3–10 reviewed

  6. 06

    1–3 proposals

These are workload limits for one authorized run. They are not conversion targets, and they do not promise that anyone will be introduced.

The feasibility argument

The corpus can grow without making every match global

  1. 01

    Shrink the search before it starts

    Purpose, lane, role, geography, time, and model version keep irrelevant intentions outside the run.

  2. 02

    Treat search as a rebuildable view

    Indexes and vectors make recall fast. They can be rebuilt because they never own identity, consent, policy, or current version state.

  3. 03

    Ask the source of truth again

    Before costly scoring or a proposal, PostgreSQL checks both directions in one bounded set query against current policy.

04

Move maintenance out of the critical path

Temporal rebuilds projections, removes stale indexes, expires runs, and reconciles delivery without moving authorization away from the online request.

The work ahead

This is where we need exceptional engineers

The architecture is specified, but production feasibility still has to be earned. We need engineers who want to measure the system under uneven load, break its assumptions, protect its privacy boundaries, and make every failure explainable.

  • Latency at p50, p95, and p99
  • Query plans under uneven real-world load
  • Database, vector, workflow, and model cost
  • Recovery from retries and partial failure
  • No private data crossing from retrieval to proposal
  • Comparable outcomes across fairness cohorts