The Lambda platform

A backend you can read,
and a runtime you can trust.

Six primitives — typed schemas, edge functions, observability, auth, queues, and migrations — wired together by the same team. No glue code, no agents, no surprises in the on-call rotation.

01 — Schemas

One model. Four typed clients. Zero contract drift.

Define your data once in Lambda's typed schema language. We compile it to a Postgres migration, an OpenAPI spec, and fully-typed SDKs for TypeScript, Go, Python, and Swift — every time you save.

Postgres migration auto-generated and reviewed in PRs
SDK versions pinned per environment
Breaking changes flagged before merge

Read the schema docs

schemas/billing.lambda.ts · ● synced v 142 · 0.3s

customers

id · textPK

email · textUNIQUE

tier · enumfree|pro|ent

created_at · tsnow()

subscriptions

id · textPK

customer_id · textFK

plan · ref(Plan)FK

status · enum3 vals

renews_at · tsnullable

.lambda/generated/clients/typescript.ts type-safe

1// Auto-generated. Edit billing.lambda.ts instead.
2const sub = await lambda.subscriptions.create(({
3  customer: customer.id,
4  plan:     "pro_monthly",
5  status:   "active",         // ← autocompletes
6});

trace · req_01HF8Q3K2ZX · 312ms 7 spans · 4 services

POST /v1/checkout 200

312ms

└ auth.verify_session

12ms

└ db.customers.find

14ms

└ fn.calc_taxes

28ms

└ http.stripe.charges slow

189ms

└ db.subscriptions.insert

19ms

└ queue.send_receipt

28ms

02 — Observability

Every request, traced. Every span, free.

Logs, metrics, and distributed traces are first-class citizens, not a $400/seat add-on. Click a slow request in the dashboard and see the exact SQL query, the function it called, and the third-party API that made it slow.

OpenTelemetry-compatible — export to Datadog, Honeycomb, or your own Jaeger
100% trace sampling on Pro · 30-day retention
Alerts on P95, error rate, and queue depth

Explore observability

03 — Runtime

Run your code where your users are.

Lambda's edge runtime ships your functions to 38 regions. Cold starts under 30ms, isolates instead of containers, and a single deploy command — lambda deploy — that you'll commit to muscle memory.

38 regions, picked automatically per request
Atomic deploys — instant rollback, every revision
Local emulator that actually matches production

Read the runtime docs

edge · live 38 regions · last 60s

iad · 18ms sfo · 22ms cdg · 11ms fra · 14ms nrt · 24ms syd · 42ms bom · 31ms

GET /api/me 11ms

POST /api/orders 42ms

PUT /api/sessions 24ms

And another six things you don't need to build.

The boring infrastructure your VP keeps asking when you'll get to.

Auth, the way you wish it worked

SAML, OIDC, magic links, passkeys — and a row-level policy engine that reads like English.

SAMLOIDCPasskeysMagic linkSCIMMFA

Queues, cron, and retries

Durable jobs with exponential backoff, dead-letter queues, and a UI for the inevitable "what happened to that one?"

@hourly reconcile_payments 3,412 ok

@5min refresh_index 1 retry

Zero-downtime migrations

Plan, dry-run, and roll out schema changes with backfills that throttle themselves under load.

backfill_customer_tier · 62% · ETA 4m

Analytics built in

SQL-backed dashboards on the same Postgres your app runs on. No ETL, no warehouse, no Looker invoice.

Object storage with signed URLs

S3-compatible storage, image transforms at the edge, and presigned uploads that just work in the browser.

PUT /uploads/<file>

x-lambda-signed: ✓ valid · 600s

150+ integrations

First-party connectors for Stripe, Resend, Twilio, Slack, Linear, and the rest of your modern toolbox.

StripeResendTwilioSlackLinearPostHogDatadog+143

See it run, in your language of choice.

The same query, four ways. Pick your stack — we generate the SDK, you write the code.

// Find every active Pro subscription that renews this week.

import { lambda } from "@acme/lambda";

const renewals = await lambda.subscriptions.list(({
  where: {
    plan:      "pro_monthly",
    status:    "active",
    renews_at: { lte: lambda.days(7) },
  },
  include: { customer: true },
  limit: 100,
});

for (const sub of renewals) {
  await lambda.queue.send("renewal_reminder", { id: sub.id });
}

// Same query, idiomatic Go. Errors elided for brevity.

import "github.com/acme/lambda-go"

renewals, _ := lambda.Subscriptions.List(ctx, &lambda.SubscriptionListParams{
    Plan:     "pro_monthly",
    Status:   "active",
    RenewsAt: lambda.LTE(time.Now().Add(7 * 24 * time.Hour)),
    Include:  []string{"customer"},
    Limit:    100,
})

for _, sub := range renewals {
    lambda.Queue.Send(ctx, "renewal_reminder", lambda.M{"id": sub.ID})
}

# Same query, Pythonic. Async by default.

from acme.lambda import lambda_

renewals = await lambda_.subscriptions.list(
    where={
        "plan":      "pro_monthly",
        "status":    "active",
        "renews_at": { "lte": lambda_.days(7) },
    },
    include={"customer": True},
    limit=100,
)

for sub in renewals:
    await lambda_.queue.send("renewal_reminder", id=sub.id)

# Bare HTTP — every SDK is built on this.

curl https://api.lambda.dev/v1/subscriptions \
  -H "Authorization: Bearer $LAMBDA_KEY" \
  -H "Content-Type: application/json" \
  -G \
  --data-urlencode 'where[plan]=pro_monthly' \
  --data-urlencode 'where[status]=active' \
  --data-urlencode 'where[renews_at][lte]=2026-05-05T00:00:00Z' \
  --data-urlencode 'include=customer' \
  --data-urlencode 'limit=100'

// HTTP/1.1 200 OK · application/json · 24ms · iad

{
  "data": [
    {
      "id":        "sub_01HF8Q3K2ZX",
      "plan":      "pro_monthly",
      "status":    "active",
      "renews_at": "2026-05-03T14:21:00Z",
      "customer": {
        "id":    "cus_01HF8Q1A0PQ",
        "email": "maya@acme.co",
        "tier":  "pro"
      }
    }
    // 99 more rows…
  ],
  "page": { "limit": 100, "next": "cur_..." }
}

Ship this week

Six primitives.
One afternoon to production.

Read the docs, run npx lambda init, and have a typed, observable backend deployed before lunch ends.

Start free trial Read the docs

A backend you can read,and a runtime you can trust.