Repository navigation
Architecture TypeScript
The third candidate. This page describes how the language-neutral design on Architecture Overview would be built in TypeScript on Node.js, at the same depth as Architecture: Go and Architecture: Rust, so that the three can be compared fairly on Stack Comparison. It is a design; nothing is implemented yet. Versions are those published on the npm registry and the Node.js release schedule on 1 November 2026, and will be refreshed when work starts.
In short: one Node.js process running Fastify 5 with zod v4 schemas that are at once the TypeScript types, the request and response validation and the OpenAPI 3.1 document. node-postgres (pg) reads the read contract; queries are typed with Kysely, whose types are generated from the contract stub. Because pg's query_timeout is only a client-side timer, the 2 second deadline is enforced on the server by SET LOCAL statement_timeout inside a read-only transaction, plus a PostgreSQL cancel request sent when the request's AbortSignal fires; a connection that had a cancel sent is never reused. Keys, limits, quotas, priority admission and cache are in-process. Estimated 60–120 MB resident memory; image target 80 MB or less compressed.
| Concern | Choice | Why | Alternatives rejected |
|---|---|---|---|
| Runtime | Node.js 26 LTS (Active LTS since 28 October 2026); Node.js 24 LTS as the fallback | long support window; native AbortSignal.any, using declarations, built-in zstd in zlib, type stripping for scripts |
Bun and Deno (younger, compatibility edge cases; see [[Languages and Frameworks |
| Language | TypeScript 7 (the native compiler), strict, noUncheckedIndexedAccess, exactOptionalPropertyTypes
|
the strictest settings close the common null and index holes; the native compiler makes type checks fast | plain JavaScript with JSDoc (weaker checking) |
| HTTP framework | Fastify 5 | schema-driven routes, a typed hook lifecycle, fast JSON serialisation from the response schema, maintained first-party plugins for compression, ETag, helmet and event-loop pressure | Hono: portable and well typed, but its value is runtime portability we do not need, and ETag, rate limiting and event-loop shedding would have to come from third parties or our own code. NestJS: decorators and dependency injection add a layer that hides SQL and deadline control, and decorator-driven OpenAPI duplicates the types. Express 5: no schema-driven validation or serialisation; OpenAPI only through add-ons that drift from the code |
| Schemas and OpenAPI 3.1 | zod v4 + fastify-type-provider-zod + @fastify/swagger
|
one zod schema per DTO is the type, the validator and the JSON Schema (draft 2020-12, as OpenAPI 3.1 requires) | TypeBox (a second schema dialect for no gain), spec-first generators such as openapi-typescript (a second source of truth) |
| Driver |
pg (node-postgres) 8 with its pool |
the most widely used PostgreSQL driver for Node; pure JavaScript; first-class OpenTelemetry instrumentation; the official Kysely dialect | postgres.js (has a built-in cancel(), but a community Kysely dialect and smaller instrumentation support; viable, revisited if the cancel helper below proves fragile), pg-native (a native addon in the image) |
| Queries |
Kysely + kysely-codegen against the contract stub |
typed query building against generated view types; compiles to SQL plus parameters, which the project's own executor runs under the deadline | pgTyped (closest to sqlc, but its last release is from early 2025), sqlc's TypeScript plugin (experimental), Drizzle and Prisma (ORMs that expect to own migrations; weak PostGIS support in Prisma) |
| Access-store migrations | node-pg-migrate 9 with plain SQL files | simple, its own version table, runs as the migrate subcommand |
Knex migrations (pulls in Knex), Prisma Migrate and drizzle-kit (schema ownership models) |
| Configuration | a zod v4 schema as the declaration, yaml for the file, a small own loader |
the same schema library as the API; bounds, defaults and descriptions in one place; the reference is generated from the schema's JSON Schema | convict (its own schema language), env-schema and @fastify/env (Ajv: a second schema language, environment only), @t3-oss/env-core (environment only, no file layer), dotenv (no validation) |
| Rate limiting | own GCRA limiter per key (a few dozen lines) | exact Retry-After from the theoretical arrival time |
@fastify/rate-limit (fixed windows allow a double burst at the window edge; kept in reserve for a coarse per-IP guard) |
| Admission | own small module | priority, reserved shares, aging, wait estimate; permits released through using
|
p-limit and p-queue (no priorities with reserved shares, no wait estimate) |
| Event-loop protection | @fastify/under-pressure |
sheds with 429 overloaded when event-loop delay or heap use crosses a configured line |
none built in elsewhere |
| Cache |
lru-cache 11 |
maxSize with a size function, per-entry TTL, fetchMethod that collapses concurrent loads (single-flight) |
mnemonist (no TTL or loader), a hand-written map |
| Compression |
@fastify/compress (gzip, brotli, optional zstd from Node's zlib) |
minimum size, correct Vary
|
a proxy-level compressor (loses per-route control) |
| Logs | pino 10 (Fastify's built-in logger), JSON to stdout, redact paths |
fast, structured, no transport thread needed | winston (slower, more configuration) |
| Tracing and metrics | OpenTelemetry JS (@opentelemetry/sdk-node, @fastify/otel, @opentelemetry/instrumentation-pg); prom-client on the loopback metrics listener |
standard; @fastify/otel is the Fastify team's replacement for the deprecated community instrumentation |
— |
| Geometry | a small own polyline decoder | route decoding only; heavy geometry stays in PostGIS | turf (algorithms not needed) |
| Tests | vitest 5, @testcontainers/postgresql with a PostGIS image, Fastify inject, fast-check 4 property tests, Jazzer.js for coverage-guided fuzzing of parsers |
— | Jest (slower, weaker ESM support) |
| Quality | typescript-eslint (strict-type-checked, switch-exhaustiveness-check, no-floating-promises), dependency-cruiser layer rules, knip (unused code and dependencies), npm audit and OSV scanning, oasdiff, Spectral |
— | — |
| Documentation | Scalar (static) + Astro Starlight guide | — | Redoc |
viafrei-api/
├── src/
│ ├── main.ts # serve | migrate | keys | usage | config {check,show,docs} | openapi | version
│ ├── domain/ # pure: no Node APIs, no zod, no pg, no Fastify
│ │ ├── shared/ # TimeWindow, GeoPoint, Area, Price (fixed point, bigint-backed), Result types
│ │ ├── provenance/ # SourceFamily, Attribution, Licence, notes
│ │ ├── places/ roads/ energy/ parking/ transit/ accessibility/ weather/ rules/
│ │ └── access/ # key, plan, scope, tier, the licence decision (a pure function)
│ ├── app/ # one module per feature (use cases); ports only
│ │ ├── motorway-conditions.ts roadworks-ahead.ts route-briefing.ts refuel-options.ts …
│ ├── adapters/
│ │ ├── store/ # the ONLY code that knows the read contract
│ │ │ ├── contract.gen.ts # kysely-codegen output from the contract stub (generated, committed)
│ │ │ ├── db.ts # Kysely instance used only to compile queries
│ │ │ ├── run-bounded.ts # the deadline executor (transaction, statement timeout, cancel)
│ │ │ ├── cancel-request.ts # the PostgreSQL CancelRequest on a fresh socket
│ │ │ ├── mapping/ # total mapping tables, one file per code list
│ │ │ └── readers/ # one file per port implementation
│ │ ├── access-store/ # keys, plans, audit, usage
│ │ │ └── migrations/ # plain SQL
│ │ ├── cache/ # result cache, freshness versions, ETag computation
│ │ └── http/
│ │ ├── server.ts # Fastify instance, plugin order, listeners
│ │ ├── hooks/ # request id, deadline, key, licence gate, rate limit, quota, ETag, admission
│ │ ├── routes/ # one file per feature: zod schemas + handler
│ │ ├── dto/ # public shapes (zod), GeoJSON builders
│ │ └── problem.ts # RFC 9457 type, error handler, problem catalogue
│ └── runtime/ # config, admission, rate limit, metering, telemetry, lifecycle
├── contract/ # the read-contract file and stub, delivered by the version-sync pull request
├── api/openapi.json # exported by the `openapi` subcommand; CI fails on drift
├── docs/ bench/ fuzz/
├── test/
│ ├── unit/ property/ db/ # db = testcontainers PostGIS
│ ├── http/ # inject-based handler tests, response validation
│ └── fixtures/
├── .dependency-cruiser.cjs eslint.config.ts tsconfig.json vitest.config.ts
├── package.json package-lock.json
└── Dockerfile
Dependency direction: main → adapters → app → domain, and adapters → runtime. A dependency-cruiser rule refuses any import of pg, kysely, fastify or zod from domain or app, and any import of adapters/store from outside it except the composition root. The rule runs in CI and in the pre-push lint.
// domain/roads/ports.ts
export interface SituationReader {
inCorridor(s: RequestScope, c: Corridor, w: TimeWindow, f: Filter): Promise<Read<RoadSituation[]>>;
history(s: RequestScope, r: RoadRef, w: TimeWindow, cursor: Cursor | null, limit: number): Promise<Read<Page<Observation>>>;
}
// Read<T> = { value: T; provenance: ProvenanceSet }RequestScope carries the deadline, an AbortSignal, the allowed source families, the language, the key id and the tier as plain data. Domain value types are branded (RoadRef, StopPlaceId, Price) so that a raw string or number cannot be passed where a validated value is expected.
Fastify's hooks run in a fixed order; the cheap checks sit in the earliest hooks so that a 304 or a refusal never reaches the database.
sequenceDiagram
autonumber
participant E as Edge (TLS)
participant H as Fastify hooks
participant R as Route handler
participant U as Use case
participant S as Store adapter
participant P as PostgreSQL
E->>H: GET /v1/motorways/A8/conditions
H->>H: onRequest - request id, deadline timer, AbortController
H->>H: onRequest - key lookup (lru-cache, constant-time compare)
H->>H: onRequest - licence gate, allowed source families
H->>H: onRequest - GCRA rate limit, then quota
H->>H: preValidation - zod parses params and query
H->>H: preHandler - ETag matches freshness? then 304, no database work
H->>H: preHandler - result cache hit? then 200
H->>H: preHandler - admission permit for the tier, or 429 with Retry-After
H->>R: typed request
R->>U: domain values and request scope
U->>S: port call
S->>P: begin read only, set local statement_timeout = remaining ms
S->>P: compiled Kysely query, limited to the allowed families
Note over S,P: on abort a CancelRequest goes out on a fresh socket and the connection is destroyed, not pooled
P-->>S: rows
S-->>U: domain objects and provenance
U-->>R: result
R-->>H: DTO, serialised from the response schema
H-->>E: onSend - ETag, Cache-Control, RateLimit headers, compression
H->>H: onResponse - permit disposed, usage counted, access log
node-postgres documents query_timeout as the time after which the client call gives up; the query keeps running on the server. The design therefore does not rely on it for the deadline. Every read goes through one executor in the store adapter:
// adapters/store/run-bounded.ts (abridged)
export async function runBounded<R>(scope: RequestScope, q: CompiledQuery<R>): Promise<R[]> {
const ms = scope.remainingMs(); // an integer from the clock, never request text
if (ms < cfg.db.statementTimeoutFloorMs) throw new DeadlineExhausted();
const client = await pool.connect();
let reusable = true;
const onAbort = () => { reusable = false; void sendCancelRequest(cfg.db, client.processID, client.secretKey); };
scope.signal.addEventListener("abort", onAbort, { once: true });
try {
await client.query(`begin read only; set local statement_timeout = ${ms}`);
const res = await client.query<R>({ text: q.sql, values: [...q.parameters], query_timeout: ms + cfg.db.cancelGraceMs });
await client.query("commit");
return res.rows;
} catch (e) {
reusable = reusable && (await rollbackWithin(client, cfg.db.cancelGraceMs));
throw e;
} finally {
scope.signal.removeEventListener("abort", onAbort);
client.release(!reusable); // a truthy argument destroys the connection
}
}- The server-side statement timeout is the primary stop. The server ends the statement at the budget even if every client-side measure were lost. The value is a number computed from the clock, never text from the request.
-
The request's
AbortSignalis aborted by the deadline timer and by the client's socket closing. On abort, the executor sends a PostgreSQL CancelRequest (the 16-byte message carrying the backend process id and secret key the driver received at connect) on a fresh socket, so the cancel needs no free pool connection, exactly when the pool may be exhausted.pgcontains an undocumented method that does the same; the project keeps its own twenty-line helper so that the behaviour is pinned by its own tests rather than by an internal API. - A connection that had a cancel sent is never returned to the pool. A cancel can arrive after the query finished and hit the next statement on that connection (the same race that tokio-postgres documents), so the executor destroys it. A connection whose transaction failed is reused only if a rollback answers within the cancel grace.
-
query_timeoutis only a backstop set to the budget plus the grace: it frees the request if neither the server nor the cancel answers, and the connection is then destroyed. - Running
pg_cancel_backend(pid)from another pooled connection was rejected: it needs a free connection exactly when there may be none.
Round trips. pg does not pipeline, so a read costs three round trips: begin read only; set local … (one simple-protocol message), the parameterised query, and commit. On a local socket this is expected to be well under a millisecond; to confirm in the benchmark (check 5), against Go's single-round-trip batch.
node:crypto: createHmac('sha256', pepper) and timingSafeEqual for verification, randomBytes for secrets, a small, fuzzed base62 codec with a checksum. The key cache is an lru-cache whose fetchMethod collapses concurrent first lookups into one query; negative results are cached briefly. Revocations arrive through a PostgreSQL LISTEN on a dedicated client outside the pool and evict the key at once; a reconnect loop re-subscribes and clears the cache on reconnect so nothing stale survives a gap.
-
Rate limit: a GCRA state (one theoretical arrival time) per key, held in an
lru-cachewith idle expiry. A request that would exceed the limit gets429 rate-limitedwithRetry-Afterrounded up from the arrival-time difference. -
Admission: one object with three queues of waiters (critical, standard, bulk), each waiter a promise resolver plus its
AbortSignal.acquire(tier, signal)grants, enqueues, or refuses at once when the moving-average wait estimate exceeds the remaining budget. It returns a permit implementingSymbol.dispose, so a handler writesusing permit = await admission.acquire(...)and the permit is released on every exit path, including exceptions; an aborted waiter removes itself from its queue. Because JavaScript runs one handler at a time, the state needs no lock; the hard part is async ordering, which a deterministic simulation on a fake clock tests (vitest's fake timers). -
Event-loop pressure:
@fastify/under-pressurewatches event-loop delay and heap use and sheds with429 overloadedbefore latency degrades for everyone. -
Composed features: a small
mapLimitwith a concurrency limit equal to the permits granted; each part getsAbortSignal.any([request, partTimeout])as its own sub-deadline, and its error becomes the part's status. -
Metering: counters in a
Map, swapped and flushed by an unref'd interval timer as one batched upsert (unnestof arrays); a final flush runs on shutdown.
lru-cache with maxSize in bytes, a size function and per-entry TTL; fetchMethod gives single-flight loading. ETags are derived from the freshness versions of the families read plus the normalised query (hashed with crypto.hash), so a 304 is decided before any database work, as in the other designs.
| Memory item (estimate) | Size |
|---|---|
| Node.js runtime, V8 heap and code at idle | ~40–60 MB |
| Result cache | 16 MiB (configurable) |
| Key cache | a few MB |
| Connections | well under 1 MB each, client side |
| Garbage-collection headroom | ~20–30 % of the heap |
Estimated steady state 60–120 MB; container limit 256 MiB, with V8's old-space limit (--max-old-space-size) set below it so that the collector works harder before the kernel intervenes. These are estimates, to be replaced by the benchmark's figures (check 4).
-
@fastify/swaggerwith the zod type provider generates OpenAPI 3.1 from the route schemas; zod v4's native JSON Schema output targets draft 2020-12. The document is served at/openapi.jsonand exported by theopenapisubcommand. Every route declares itsoperationId, summary, description, tags, security requirement and the extensions for scope, source families and MCP counterpart; a docs lint refuses a route that lacks one. - Request parsing and response serialisation use the same zod schemas. In tests every response is also validated against its schema; in production the serialiser strips unknown fields, which keeps internal fields from leaking even if a mapping forgets one.
- Fastify has no built-in RFC 9457 model, so
problem.tsdefines aProblemerror class, the catalogue oftypeURIs and asetErrorHandlerthat rendersapplication/problem+json, maps zod validation failures to400 invalid-parameterwitherrors[], and turns anything unknown into500 internalwith only the request id. This is a few dozen lines. -
application/geo+jsonis a second response content type with its own schema; geometry built by PostGIS passes through as pre-serialised JSON.
The zod schema is the declaration: each key has its type, default, bounds (.min(), .max()) and description (.meta()), and a secret() wrapper. Defaults, then a YAML file, then environment variables (prefix plus upper-snake key path, the same key paths as the other designs). Unknown file keys and unknown prefixed variables are refused; all violations are printed together, then the process exits with the configuration error code. Secrets are a class whose toString, toJSON and util.inspect forms are <redacted>, and pino's redact covers the same paths. config docs generates the reference from the schema's JSON Schema. See Configuration.
- vitest with
@testcontainers/postgresqlon a PostGIS image for mapping, role, cancellation and query-plan tests; Fastifyinjectfor handler tests without a socket; every recorded response validated against the OpenAPI document; Schemathesis against the booted container; k6 for the latency and overload scenarios. - fast-check property tests for corridor arithmetic, area bounds, cursor round trips, the licence gate and the admission controller's invariants (a permit is never lost, a higher tier is never starved).
- Jazzer.js for coverage-guided fuzzing of the cursor codec, key codec, polyline decoder, parameter parsers and the YAML loader; it runs on the normal Node toolchain.
- The cancellation test drives both paths (deadline and client disconnect) a thousand times and asserts, through the database's activity view, that the backend is idle within the target and that no cancelled connection is ever handed out again.
-
tsc --noEmitwith the native compiler, typescript-eslint with type-aware rules, dependency-cruiser, knip, coverage gate excluding generated code,npm auditplus OSV scanning, CodeQL for JavaScript and TypeScript. -
npm ci --ignore-scriptseverywhere; a lockfile change needs review; dependencies pinned exactly; release-please with the Node release type and npm provenance for any published client package.
Multi-stage build: install with npm ci --ignore-scripts, type-check, then bundle the server with esbuild into one ES module (all production dependencies are pure JavaScript, so there is no node_modules in the final image). The final stage is gcr.io/distroless/nodejs26-debian13 as the non-root user, pinned by digest, with only the bundle and the generated OpenAPI file. Image target 80 MB or less compressed, most of it the Node runtime; no shell, no package manager. CI scans the layers for secrets and known vulnerabilities.
| Risk | Mitigation |
|---|---|
| Server-side cancellation is hand-built (the driver's timeout is client-side) | statement timeout first; own CancelRequest helper with its own tests; never reuse a cancelled connection; the 1 000-iteration cancellation check in the benchmark; postgres.js as the fallback driver |
| One event loop: a CPU-heavy handler delays every request | JSON and geometry are built in PostgreSQL; response serialisation from schemas; @fastify/under-pressure; an event-loop-delay budget in the latency tests |
| Garbage-collection pauses and a larger heap under a tight memory limit | byte-bounded caches, a V8 old-space limit below the container limit, footprint verified in the benchmark |
| npm supply chain: a large transitive dependency tree and install scripts | few direct dependencies, --ignore-scripts, exact pins, lockfile review, a cooling-off period before adopting new releases, bundling so that only reachable code ships, npm audit and OSV in CI |
| Type erasure: types are compile-time only | zod at every boundary (requests, configuration, the contract stub check), branded domain types, no any (lint), exhaustive switches (lint) |
| The zod type provider is a community package | it is thin glue over standard OpenAPI output; the route schemas are plain zod, so a move to another provider is mechanical |
| Ecosystem churn (major versions of the framework, zod and the provider) | Renovate with grouped updates, the OpenAPI drift check and response validation catch any shape change |
| Licence matrix not yet signed off | the gate defaults to deny; families are enabled one at a time |
The phases are the same for all three stacks; the relative effort is a judgement, not a schedule. "Low", "medium" and "high" compare the phases of this design with each other.
| Phase | Content | Relative effort | Note for TypeScript |
|---|---|---|---|
| 0. Skeleton | repository, lint and layer rules, config loader, Fastify with health, readiness and /openapi.json, CI, image |
low | the fastest of the three to stand up: no compile step to tune, and the toolchain is familiar |
| 1. Store adapter | contract stub, kysely-codegen, runBounded, CancelRequest helper, mapping tables, cancellation tests |
high | the one phase that is harder than in Go: the cancellation path is hand-built and must be proven |
| 2. Access | keys, plans, licence gate, GCRA limiter, quotas, metering, access-store migrations | medium | standard library crypto; no framework surprises |
| 3. First features | motorway conditions, roadworks ahead, charging and refuel near a point, problems, GeoJSON | medium | zod schemas give types, validation and OpenAPI in one step |
| 4. Admission and caching | priority admission, event-loop shedding, result cache, ETag and 304
|
medium |
using makes permit release structural |
| 5. Composed features | route briefing and place overview with part statuses | medium | |
| 6. Hardening | Schemathesis, fuzzing, overload and footprint runs, documentation site | medium | footprint tuning (heap limit, cache size) is the item to watch |
Estimated the lowest of the three for the first features, because of the fast edit-and-run loop, the size of the ecosystem and familiarity with TypeScript; the store adapter (phase 1) costs more than in Go and about the same as in Rust. Over the whole design the estimate is close to Go's. See Stack Comparison.
Node.js release schedule https://nodejs.org/en/about/previous-releases · TypeScript native compiler https://devblogs.microsoft.com/typescript/typescript-native-port/ · Fastify https://fastify.dev/docs/latest/ and hooks https://fastify.dev/docs/latest/Reference/Hooks/ · fastify-type-provider-zod https://github.com/turkerdev/fastify-type-provider-zod · @fastify/swagger https://github.com/fastify/fastify-swagger · @fastify/under-pressure https://github.com/fastify/under-pressure · @fastify/otel https://github.com/fastify/otel · zod JSON Schema https://zod.dev/json-schema · Hono https://hono.dev/docs/ · NestJS https://docs.nestjs.com/ · Express https://expressjs.com/ · node-postgres client options https://node-postgres.com/apis/client · postgres.js https://github.com/porsager/postgres · Kysely https://kysely.dev · kysely-codegen https://github.com/RobinBlomberg/kysely-codegen · node-pg-migrate https://github.com/salsita/node-pg-migrate · lru-cache https://github.com/isaacs/node-lru-cache · pino https://getpino.io · OpenTelemetry JS https://opentelemetry.io/docs/languages/js/ · vitest https://vitest.dev · testcontainers for Node https://node.testcontainers.org/modules/postgresql/ · fast-check https://fast-check.dev · Jazzer.js https://github.com/CodeIntelligenceTesting/jazzer.js · Schemathesis https://schemathesis.io · k6 https://k6.io · dependency-cruiser https://github.com/sverweij/dependency-cruiser · typescript-eslint exhaustiveness https://typescript-eslint.io/rules/switch-exhaustiveness-check/ · distroless https://github.com/GoogleContainerTools/distroless · npm provenance https://docs.npmjs.com/generating-provenance-statements · PostgreSQL cancel protocol https://www.postgresql.org/docs/16/protocol-flow.html#PROTOCOL-FLOW-CANCELING-REQUESTS
Versions checked on the npm registry on 1 November 2026: fastify 5.12, zod 4.6, fastify-type-provider-zod 7.0, @fastify/swagger 9.9, pg 8.23, kysely 0.29, kysely-codegen 0.20, node-pg-migrate 9.0, lru-cache 11.5, pino 10.4, @fastify/under-pressure 9.2, @fastify/compress 9.3, @fastify/otel 0.21, @opentelemetry/instrumentation-pg 0.77, prom-client 15.1, yaml 2.9, vitest 5.0, @testcontainers/postgresql 12.2, fast-check 4.10, @jazzer.js/core 4.0, typescript 7.0, typescript-eslint 8.72, hono 4.13, @nestjs/core 12.3, express 5.3.
ViaFrei API: a public, keyed, read-only REST API to live German mobility data. Design phase; nothing on these pages is a measurement of a running service. Data on viafrei.de and in every API answer is attributed to its publishers under their licences.
About
Design
- Domain Model
- API Design
- Architecture Overview
- Security and Access Keys
- Rate Limits and Priority
- Performance and Caching
- Configuration
- Observability
Data Model
Technical specification
-
Technical Specification
- Interface
- Scope, Conventions and References
- Protocol
- Common Envelope
- Resource Model
- Endpoints, Places
- Endpoints, Roads
- Endpoints, Energy and Parking
- Endpoints, Public Transport and Accessibility
- Endpoints, Weather Risk, Driving Rules and Composed Features
- Service Endpoints
- Errors
- Authentication and Authorisation
- Rate Limiting, Quotas and Priority
- Data Licensing and Attribution
- Compatibility and Versioning
- OpenAPI Skeleton
- Quality
- Delivery and operations
- Interface
Testing
- Testing Strategy
- Testing and Quality (design summary)
Engineering
Technology choice
- Technology Evaluation
- Architecture: Go
- Architecture: Rust
- Architecture: TypeScript
- Stack Comparison
- Benchmark Plan
Reference