Not a list of technologies. The reasoning behind each one, and what it costs us when we're wrong.
Eight things we do, and how we do them.
Architecture
Decide the guarantees before the diagram.
We start from the invariants a system must never violate — ordering, consistency, durability — and derive the structure from those. Boundaries follow data ownership, not org charts, so a service can be understood without reading the ones around it.
Backend
Go services that stay simple under load.
Statically-compiled Go behind gRPC, with Postgres as the system of record and Redis where latency demands it. Handlers stay thin, domain logic stays testable, and anything slow moves to a queue rather than a bigger machine.
Frontend
Server-first React that ships less JavaScript.
Next.js App Router with React Server Components by default. Client components are the exception, reached for only where interaction demands them, which keeps the hydration cost proportional to what's actually interactive.
Mobile
One Flutter codebase, native where it counts.
Flutter for iOS and Android against the same API contract the web uses, dropping to platform channels for the things that genuinely need to be native — biometrics, secure storage, background sync.
Cloud & infrastructure
Every environment is a Terraform plan.
GCP, described entirely in Terraform. There is no console-clicked resource anywhere in production, which means an environment can be rebuilt from an empty project and a git checkout.
DevOps
Deploys are boring on purpose.
Trunk-based development, containers built once and promoted through environments, progressive rollout with automatic rollback on SLO burn. The engineer who wrote it is the one who ships it.
AI
Models narrate. Code computes.
Retrieval over your own data, deterministic aggregation before inference, and evaluation suites that gate every prompt change. If a model states a number, that number was calculated in code first — the model is never the source of truth.
Data
Schema is a contract, migrations are code.
Normalised Postgres with explicit, reversible migrations that run in CI before they run anywhere else. Analytics reads from replicas, so a slow dashboard query can never take the product down with it.
The stack we bet on.
Chosen for operational boredom, not for the changelog.
- Go — Services
- TypeScript — Web
- Next.js — Frontend
- Flutter — Mobile
- Python — AI / data
- PostgreSQL — System of record
- Redis — Cache / presence
- Kubernetes — Orchestration
- Docker — Packaging
- Terraform — Infrastructure
- GCP — Cloud
- gRPC — Transport
How we decide what to build, and how.
Four commitments that survive contact with a deadline.
Correctness is a feature.
A system that is fast and wrong is just wrong sooner. We pick the guarantee first — ordering, consistency, durability — and then make it fast inside that constraint.
Boring infrastructure, ambitious products.
Postgres, Go, containers, Terraform. We spend our novelty budget on the product surface, not on the parts that page someone at 3am.
AI that reasons over facts, not vibes.
Models narrate; they don't compute. Every number an AI feature reports is derived deterministically before the model ever sees it, and every claim traces back to its source.
Own the thing you ship.
The engineer who builds a service runs it. That closes the loop between the design decision and the pager, which is the only thing that reliably produces good design decisions.
Have a system that needs to hold up?
Bring us the hard part. We'd rather work on the thing that scares you than the thing that's easy.