Examples

Session middleware, per-user data isolation, validated bodies, cursor pagination, a cache in front of a hot read, and a job that sends the daily digest.

• Session middleware and ownership checks
• Validating a JSON body
• Cache-aside with tags
• Fan-out work onto a queue

An upload that returns immediately. The request validates and stores the original, then a worker resizes it, emits an event, and pushes progress to the browser over SSE.

• Streaming an upload to a disk
• Reporting progress from inside a job
• Emitting an event the UI is listening for
• Streaming progress to the client

A chat server where joining a room is permission-checked, presence is tracked per room, and messages fan out through rooms rather than a global broadcast.

• Authorising a socket join
• Scoping broadcasts to a room
• Tracking presence without a database write
• Reconnecting clients cleanly

Row-level isolation with a per-request tenant scope, a scoped table wrapper that removes the chance of forgetting the filter, and tenant id attached to every span.

• Resolving tenant from the host
• A scoped query helper
• Roles per workspace
• Tenant as a span attribute

Outbound webhooks that survive a flaky consumer: HMAC over the raw bytes, exponential backoff, and a dead-letter state for endpoints that will never recover.

• Signing and verifying with HMAC
• Constant-time signature comparison
• Distinguishing 4xx from 5xx on retry
• Replaying a dead-letter queue

An append-only trail where each row commits to the previous one, so deleting or editing a record breaks every link after it and a verifier proves it.

• Stable canonical JSON serialisation
• Chained hashes
• Detecting a tampered or deleted row
• Storing diffs instead of whole rows

FTS5 with a synchronised index, ranked results, and a cache that does not go stale. The index is maintained by triggers, so nothing can write without it.

• FTS5 with triggers
• Ranking and snippets
• Cached queries
• Rebuildable index

Flags declared once so a rename is a type error, read through a singleflight cache, overridable per user, and pushed to open browsers over a socket.

• A typed flag set
• Singleflight flag reads
• Tag-based invalidation
• Server hydration to avoid a flash

A limiter that counts inside a single statement so concurrent requests cannot both slip past the limit, with honest Retry-After values and per-key tiers.

• Atomic increments
• Retry-After and RateLimit headers
• Per-key instead of per-IP limits
• Expiring the counter table

Call sites declare an intent; the hub routes it to email, in-app and realtime according to per-user preferences, and batches digests overnight.

• One intent, many channels
• Per-user preferences
• Digest batching
• Live unread badge

Scheduled jobs that do not double-run, do not stampede, and survive a restart. Leases are taken in the same statement that reads them.

• Overlap locking
• Jitter
• Misfire handling
• Timezone buckets

A 400MB file that never enters memory, never blocks a request, and reports progress while it runs. Includes a dry run so you see the problems before committing.

• Streaming parser
• Batched writes
• Progress reporting
• Dry run first

Event recording on a queue so it never sits on the request path, with daily rollups that keep queries fast as the raw table grows.

• Non-blocking capture
• Daily rollups
• Idempotent aggregation
• Funnels

Plans, proration, idempotent webhooks, dunning, and usage metering that survives a retry.

• Money in minor units
• Proration maths
• Idempotent charges
• Dunning sequence

User management, session revocation, and audited impersonation behind a permission guard.

• Permission-guarded routes
• Audited impersonation
• Session revocation
• Read-only mode

A tool-calling agent with full tracing, token and cost accounting, and a hard budget cap.

• Tools as child spans
• Argument validation
• Cost caps
• Human handoff

Per-plan quotas with soft and hard limits, predictive warnings, and usage headers.

• Atomic counting
• Soft vs hard limits
• Predictive exhaustion
• Quota headers

The on-call console you would otherwise write by hand, assembled from the framework's own tracing.

• Issue queue and triage
• Trace waterfall
• Deploy correlation
• Alerting on edges

All of Yatta behind a Next.js frontend: auth, database, jobs, events, storage, mail, cache, realtime and observability, with one trace spanning both.

• CORS with credentials
• Session auth from React
• SSE progress into state
• Feedback tied to a trace