Skip to main content
Technology

A stack should feel like a system, not a souvenir collection.

Tools are chosen for the job they do and how well they fit together. Here's what we reach for, and the standards that come with every project.

The stack

ERP

  • Odoo
  • Python
  • OWL
  • QWeb
  • PostgreSQL

Web

  • Next.js
  • React
  • TypeScript
  • Tailwind CSS
  • Three.js

Backend & AI

  • FastAPI
  • Node.js
  • Redis
  • pgvector
  • LLM APIs

Mobile

  • Flutter
  • React Native
  • SQLite

Infrastructure

  • Docker
  • Kubernetes
  • Terraform
  • GitHub Actions
  • Prometheus
  • Grafana

Engineering standards on every project

  • Version control with reviewed pull requests
  • Automated tests and CI on every change
  • Infrastructure defined as code
  • Secrets in a manager, never in repositories
  • Documentation: README, architecture notes, runbooks
  • Accessibility and performance budgets for user interfaces

Curious what we think of newer tools?

Our tech radar lists what we adopt, trial, assess, and avoid, with reasons.

How we choose technology

As a small team, we can't afford fashionable tools that create work without creating value. We choose mature, well-documented technology that our clients can hire for, that plays well with the rest of the stack, and that we can support confidently for years. New tools earn their place through trials on suitable projects before they become defaults.

The result is a deliberately compact stack: Odoo and PostgreSQL at the heart of business systems, TypeScript and React for interfaces, Python for services and AI, and containers with infrastructure as code underneath.

Why these choices

ChoiceReason
OdooBroad, modular ERP with an open codebase and a large ecosystem
PostgreSQLReliable, feature-rich, and the database behind Odoo
TypeScript and ReactWidely known, strongly typed, and productive for complex interfaces
Python and FastAPINatural fit for Odoo extensions, data work, and AI services
Docker and TerraformReproducible environments and infrastructure anyone can review

Standards that travel with every project

Every project gets the same foundations, whatever its size: code in version control with reviewed changes, automated tests and CI from the first week, infrastructure defined as code, secrets kept in a manager, monitoring and backups set up before launch, and documentation written for the next person who will maintain the system.

These standards matter even more for a startup's clients. They mean your system doesn't depend on any one person, including us, and can be handed to your own team or another partner without a painful rescue project.

What you receive at handover

  • Source code in your own repository
  • Architecture notes and decision records
  • Deployment pipeline and infrastructure code
  • Runbooks for common operations and incidents
  • Access to every account, in your name

Designing for the long term

Most of the systems we build will be running long after the project ends, maintained by people who weren't in the room when decisions were made. We design with that in mind: clear boundaries between components, small extensions instead of deep changes to core products, and decision records that explain why things are the way they are.

We also design for upgrades. Odoo releases a new major version regularly, frameworks evolve, and cloud services change. Systems built on standard features and clean extension points move forward with far less effort than ones built on patches and shortcuts.

Principles in practice

PrincipleWhat it looks like
Boring by defaultProven tools unless there's a clear reason to try something new
Extend, don't patchOdoo customized through inheritance and modules, never core edits
One owner per recordEvery piece of data has a system of record agreed up front
Fail loudlyIntegrations retry, log, and alert instead of failing silently
ObservableMonitoring and logs from the first deployment

When we deviate from the default stack

Defaults exist so we don't relitigate the same decisions on every project. They're not rules. We deviate when a client already runs something well, when a regulation requires a specific platform, or when a different tool is clearly better for the job.

When we do, we write down why, what it costs, and who will maintain it. A slightly unusual choice that your team already understands beats our favourite tool that nobody on your side can support.

How we decide between build, buy, and configure

SituationUsuallyBecause
Standard business processConfigure the ERPCheapest to run and upgrade
Common need, mature products existBuy or subscribeSomeone else maintains it
Real competitive differenceBuild a clean extensionWorth owning, kept separate from the core
Short-lived experimentBuild the smallest versionLearn first, invest later

Observability is part of the architecture

Every system we ship comes with logs you can search, metrics for the few numbers that matter, and alerts that reach a person. We decide what to measure during design, not after the first incident, because the questions you'll need to answer at 2 a.m. are predictable.

The same applies to integrations: each one gets logging, retries, and a reconciliation report, so a failed message becomes a visible task instead of a silent difference between systems.

Security and data protection by design

Access rules, encryption, and audit trails are designed in from the start rather than bolted on before launch. Each integration gets its own credentials with only the permissions it needs, secrets live outside the code, and personal data is kept to what the system actually requires.

We document where data lives, who can reach it, and how long it's kept, so your team can answer customer and auditor questions without reverse-engineering the system.

Decisions you can read later

Every significant choice gets a short written record: the options considered, what we chose, and why. Future teams inherit the reasoning, not just the result.

Frequently asked questions

Can you work with a stack you don't normally use?
Often, yes, especially for maintenance and integrations. For new builds we'll be honest about whether our defaults would serve you better.
Will we be locked into your tools?
No. We favour open-source and widely used platforms, and you own the code, accounts, and documentation.