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
| Choice | Reason |
|---|---|
| Odoo | Broad, modular ERP with an open codebase and a large ecosystem |
| PostgreSQL | Reliable, feature-rich, and the database behind Odoo |
| TypeScript and React | Widely known, strongly typed, and productive for complex interfaces |
| Python and FastAPI | Natural fit for Odoo extensions, data work, and AI services |
| Docker and Terraform | Reproducible 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
| Principle | What it looks like |
|---|---|
| Boring by default | Proven tools unless there's a clear reason to try something new |
| Extend, don't patch | Odoo customized through inheritance and modules, never core edits |
| One owner per record | Every piece of data has a system of record agreed up front |
| Fail loudly | Integrations retry, log, and alert instead of failing silently |
| Observable | Monitoring 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
| Situation | Usually | Because |
|---|---|---|
| Standard business process | Configure the ERP | Cheapest to run and upgrade |
| Common need, mature products exist | Buy or subscribe | Someone else maintains it |
| Real competitive difference | Build a clean extension | Worth owning, kept separate from the core |
| Short-lived experiment | Build the smallest version | Learn 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?
Will we be locked into your tools?
Keep exploring
Next step
Got a tangled system? Let's untangle it together.
Thirty minutes with an engineer, no slide deck required. You'll leave with a clearer picture, whether or not we work together.
