Engineering
Chosen for the hard parts, not for the list.
A technology list tells you almost nothing on its own. What matters is why each one is there and what it's good at — so that's how this page is organised.
We work in a deliberately narrow stack. Depth in a few technologies produces better systems than a shallow familiarity with twenty, and it means the software we hand over is built on things other teams can also hire for.
By layer, and by what it's for
Mobile
Build cross-platform production applications.
Flutter, Dart
One codebase for Android and iOS, with real access to the platform underneath — background services, foreground notifications, location — through platform channels when a feature needs it.
Native platform code
Some things can't be solved at the framework layer. Battery-aware background work and OS survival get handled with platform APIs directly.
Frontend
Build web products and business interfaces.
React, TypeScript
Componentised interfaces with types that catch a whole class of mistakes before the browser does. The default for anything that will keep changing.
Next.js
Where server rendering, routing and page performance matter for a public-facing product.
Tailwind CSS
A consistent design system in the markup, which keeps interfaces coherent as more people work on them.
Backend
APIs, business logic, integrations and background services.
Node.js, TypeScript
The same language across the browser, the server and the schema — so a change to the data model surfaces as a compile error, not a production bug.
NestJS
Structured modules, dependency injection and guards. It keeps a growing permission model tractable instead of tangled, which is where most backends eventually get into trouble.
Data
Transactional data, flexible models and caching.
PostgreSQL
Relational integrity for domains with real structure — hierarchies, audit trails, anything where the database enforcing the rules beats hoping the application remembers.
Prisma
Type-safe queries and versioned migrations, so schema changes are reviewable and reversible.
MongoDB
Where the data genuinely doesn't have a fixed shape and forcing one would cost more than it returns.
Redis
Caching and fast ephemeral state, where response time matters more than durability.
Infrastructure
Deploy and operate production systems.
AWS
Where most of what we build runs. Standard, well-documented, and something another team can take over.
Docker
Reproducible builds — the same image runs in every environment, which removes an entire category of deployment surprises.
Nginx
Routing, TLS termination and serving static assets at the edge of the application.
CI/CD
Automated build, test and deploy on merge, so releasing is routine rather than an event.
AI
Integrate intelligent features into real applications.
LLM APIs
Language capabilities added to an existing product — summarising, extracting, answering — where they beat the deterministic alternative.
Retrieval over your own data
Grounding answers in your documents and records, so responses come from your information rather than the model's general knowledge.
How a technology gets chosen
The stack above isn't fixed by preference. It's what has repeatedly turned out to be the right answer for the kind of problems we work on.
When a project genuinely calls for something else, we'll use something else — and explain why before we do, not after.
The problem decides
We start from what the software has to do, and pick technology that does it well — not the reverse.
Someone else can hire for it
Standard, widely-used technologies mean you're never dependent on us being the only people who know this stack.
The simplest thing that works
Every added component is one more thing to run, secure, update and understand. It has to earn that.
Boring where it counts
For the parts that must not fail, mature and well-understood beats new and interesting.
What we build with
REACT
TYPESCRIPT
NEXT.JS
FLUTTER
DART
TAILWIND
NODE.JS
NESTJS
POSTGRESQL
PRISMA
MONGODB
REDIS
DOCKER
NGINX
AWS
LLM APIs
Want to know what we'd use for your problem?
Describe it and we'll tell you what we'd recommend, what we'd avoid, and why.