Repository navigation
Technology Evaluation
Before writing code, every serious option for each part of the API was evaluated on the same criteria and given a verdict. This page is the overview; each group has its own page with the reasoning per technology.
These follow from the Principles and from the deployment assumptions on Architecture Overview:
- Server-side query cancellation within the 2 second deadline (not only giving up on the client side).
- A small memory footprint, because the first deployment runs with a tight memory limit. Design budget: well under 200 MB of resident memory for the API, ideally far less, and nothing heavy running beside it.
- A hard cap on database concurrency, shared with the MCP server and the website.
- Strict typing and code-first OpenAPI 3.1, so documentation cannot drift from code.
- Productivity with AI coding agents, which do much of the implementation work under human review.
- Low operating cost, with fast local feedback and a simple CI.
- Fit with the read-contract design (views as the only interface to storage).
Load assumption. The design assumes modest load at the start, growing in stages (see Architecture Overview). Under that assumption every shortlisted runtime has far more throughput than needed; the database is the constraint, not the language. Throughput therefore carries the lowest weight below.
| Verdict | Meaning |
|---|---|
| Recommended | part of the planned design |
| Viable | technically sound; a fallback or second choice |
| Viable later | not needed at the first stage; planned for a later scaling stage |
| Rejected | does not fit, with the reason stated |
Scores from 1 (poor) to 5 (excellent), multiplied by the weight. These are judgements, not measurements; the Benchmark Plan tests the important ones.
| Stack | Driver and server-side cancel (×3) | Memory footprint (×2) | Throughput (×1) | Code-first OpenAPI 3.1 and typing (×3) | Auth and limits ecosystem (×1) | AI agents and existing platform tooling (×3) | Operating cost with local CI (×2) | Fit with view contracts and existing gates (×2) | Total / 85 |
|---|---|---|---|---|---|---|---|---|---|
| TypeScript / Fastify 5 (pg, zod) | 4 | 3 | 4 | 5 | 4 | 5 | 5 | 5 | 76 |
| TypeScript / Hono (Node) | 4 | 3 | 4 | 4 | 3 | 5 | 5 | 5 | 72 |
| Go / huma v2 + chi (pgx v5, sqlc) | 5 | 5 | 5 | 4 | 4 | 4 | 3 | 2 | 68 |
| TypeScript / NestJS | 4 | 2 | 3 | 4 | 5 | 4 | 4 | 5 | 66 |
| Go / Echo | 5 | 5 | 5 | 2 | 4 | 4 | 3 | 2 | 62 |
| Rust / axum (utoipa, tokio-postgres) | 4 | 5 | 5 | 3 | 3 | 3 | 2 | 2 | 56 |
| Python / FastAPI (asyncpg) | 3 | 2 | 2 | 5 | 3 | 4 | 3 | 2 | 55 |
| C# / ASP.NET Core minimal APIs (Npgsql) | 4 | 3 | 5 | 4 | 5 | 3 | 2 | 1 | 55 |
| Kotlin or Java / Quarkus native | 4 | 3 | 4 | 4 | 4 | 3 | 2 | 1 | 53 |
| Java / Spring Boot | 4 | 1 | 4 | 4 | 5 | 3 | 2 | 1 | 50 |
- The TypeScript options score highest mainly because the ViaFrei platform is written in TypeScript, so its tooling, lints and test helpers would carry over. That weight is about reuse, not about the API's own technical quality.
- Go and Rust are the owner's preferred candidates. The API lives in a separate public repository with its own CI, which removes most of the reuse advantage this table rewards. TypeScript remains a full candidate with its own design, Architecture: TypeScript.
- The three finalists are compared again, criterion by criterion and without the reuse weight, on Stack Comparison. There, Go is recommended, Rust second and TypeScript third; the sensitivity analysis on that page shows that TypeScript leads only when reuse of the platform's tooling is weighted heavily, as in this table.
| Group | Recommended | Viable or later | Rejected |
|---|---|---|---|
| [[Languages and frameworks | Technology-Languages-and-Frameworks]] | Go: huma v2 on chi with pgx v5 (Rust: axum with utoipa, and TypeScript: Fastify 5 with zod, as the other candidates) | Hono (TypeScript) |
| [[Database-generated APIs | Technology-Database-Generated-APIs]] | none | PostgREST (internal or bulk use, later); pg_featureserv (OGC endpoint, later) |
| [[Gateways and key management | Technology-Gateways-and-Key-Management]] | the existing TLS edge as a coarse per-IP guard; keys in the API itself | KrakenD (with several replicas) |
| [[Rate limiting and queues | Technology-Rate-Limiting-and-Queues]] | in-process token buckets and tier semaphores | PostgreSQL for metering and quotas; Valkey with several replicas |
| [[Data access and caching | Technology-Data-Access-and-Caching]] | the stack's native driver with server-side cancel, typed queries checked against the contract, in-process cache, ETag/304 | PgBouncer and a read replica at a later stage |
| [[Design, docs and observability | Technology-Design-Docs-Observability]] | code-first OpenAPI 3.1, Scalar, Spectral, oasdiff, minimal manual OpenTelemetry, the relevant RFCs | Redoc, typed client generation |
Each group page cites the documentation it relied on. Where a statement comes from general knowledge of a project rather than a source checked during the evaluation, the page says so. Memory figures for runtimes we do not operate are estimates.
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