The technology we build.

Applied language and vision systems, built to be measured rather than demonstrated.

The interesting question about a model in production is never whether it produces plausible output — it is what fraction of the output is wrong, in which direction, and what happens to the wrong ones. So every model call we ship is bounded by a schema, validated before it is allowed to persist, and evaluated against a held-out set that predates the prompt.

Retrieval

Vector indexes over owned content, so related material is found by meaning rather than by keyword match.

Extraction

Structured fields pulled from unstructured source text, schema-validated, with malformed output retried or discarded — never stored.

Classification

Topic, sentiment and stance, with the confusion matrix treated as the deliverable rather than the accuracy number.

Evaluation

Held-out sets, regression suites and cost-per-call tracking wired in before the feature ships, not after it misbehaves.

Agents

Tool-using loops with explicit budgets and termination conditions. An agent without a spend ceiling is an incident waiting for a trigger.

Deployment, scaling and observability across Indian and international regions.

Infrastructure work is mostly the unglamorous business of making failure boring. The target is a system where the common faults — a slow upstream, an expired credential, a region going away — produce a page, a retry and a graph, rather than a silence that someone notices a week later.

Deployment

Reproducible environments from source. A deploy that cannot be repeated from a clean checkout is not a deploy, it is an anecdote.

Scaling

Horizontal where the work is shardable, vertical where it is not, and measured before either.

Regions

Residency and failover decided per partner. Region is configuration, not an architectural rewrite.

Observability

Traces, metrics, logs and spend on one timeline, because the three explanations of an incident are usually in different systems.

Security

Least privilege, rotated credentials, and an audit trail that survives the person who set it up leaving.

Multi-tenant products, billing, entitlements and the operational spine underneath them.

Most of the cost of a SaaS product is not the feature surface. It is tenancy, entitlements, billing and the migration path — the parts that are nearly impossible to retrofit once there are paying accounts on the old shape. We build those first, on the grounds that they are the expensive things to be wrong about.

Tenancy

Isolation boundaries chosen deliberately — row, schema or database — and enforced at the query layer rather than by convention.

Entitlements

What a plan grants, resolved once at the edge of the request, so a feature check is never a database round trip.

Billing

Metering, invoicing and proration as first-class domain logic, not as a webhook handler bolted on later.

Platform engineering

The internal surfaces — admin, impersonation, backfills, feature flags — that decide whether support can resolve a ticket without an engineer.

APIs

One versioned contract, documented from the schema, with deprecation dated rather than implied.

Collection, storage and analysis at a volume that does not fit in one process.

Data platforms fail at the seams: ingestion that silently drops, schemas that drift, and an analytical copy that quietly stops matching the operational one. The work is mostly in making those three failures loud.

Ingestion

Scheduled collection from configured sources, with the filtering stage that decides what is genuinely a record and what is noise.

Storage

Operational and analytical copies kept deliberately separate, with the lag between them stated rather than assumed.

Processing

Distributed batch and stream work, idempotent, so a replay is a routine operation instead of a decision.

Schema

Migrations with a rollback path. A schema change without one is an outage with a delay on it.

Analytics

Real-time aggregates over owned data, and export of the partner’s own archive as a right rather than a feature.

Messaging, voice and notification infrastructure with delivery guarantees that survive contact with real traffic.

A notification system is judged entirely on its behaviour in the bad cases: the carrier that is degraded, the webhook that arrives twice, the recipient who has opted out since the batch was composed. Ordinary throughput is table stakes.

Messaging

Templated, localised, rate-shaped per channel, with per-recipient deduplication.

Delivery

Receipts reconciled against sends, so "delivered" is a measured state and not an optimistic one.

Notification infrastructure

Fan-out with backpressure. A queue that cannot push back is a queue that will lose work.

Consent

Opt-out honoured at send time rather than at compose time — the gap between the two is where complaints come from.

APIs

A single send contract across channels, with channel-specific behaviour surfaced rather than hidden.

Integration, workflow and compliance work in estates that predate us.

Enterprise work is rarely a greenfield problem. It is usually the question of how a new system exchanges data with several older ones that cannot be changed, on a schedule nobody controls, without becoming load-bearing for all of them.

Integration

Adapters at the boundary, so an upstream format change is a contained edit rather than a sweep through the codebase.

Workflow automation

Long-running processes with durable state, resumable after a restart.

Compliance technology

Retention, residency and audit trails implemented as system properties rather than as policy documents.

Developer platforms

Internal tooling, environments and documentation — the difference between a team of five and a team of five who can ship.