Skip to content

Technology Evaluation

mavrovde edited this page Nov 13, 2026 · 3 revisions

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.

What every option is judged on

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 vocabulary

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

Stack scoring

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

How to read this table

  • 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 overview

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

Sources and confidence

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.

Home

About

Design

Data Model

Technical specification

Testing

Engineering

Technology choice

Reference

Clone this wiki locally