Atlas
An internal console that replaced eleven spreadsheets. Service health, deploys and access control in one surface.
React · TypeScript · Go · Postgres · AWS
Software · Product · Engineering
We build software people want to use.
Brevalen is a product and engineering company building web applications, mobile products and the systems behind them - from first idea to production.
- Engagements
- Product teams, embedded
- Typical start
- Two to four weeks
- Disciplines
- Design, web, mobile, backend
- Based
- Remote, Europe & South Asia
Trusted to turn complex ideas into usable software.
- Product design
- Web applications
- Mobile apps
- APIs & backends
- Cloud architecture
- Applied AI
- Design systems
- Data platforms
We work with a small number of clients at a time, usually as an embedded product team alongside founders and internal engineering.
Software should feel inevitable.
Philosophy
The best products don't feel designed. They feel like the only sensible way the thing could have worked. Getting there is slow, specific work: understanding the problem properly, cutting what isn't needed, then building the rest carefully.
We do that work in small teams, close to the people who will use the software, with a running build from the first weeks.
Work
Selected work
A few projects that show how we think. Client names are withheld where the work is internal.
Operations
Case study · Depot
From a paper plan to a product six depots run on.
We took the whole problem — research, interface, architecture, delivery — and shipped it as one product team.
- 01
The problem
Six depots planned a day on paper. Nobody could see the whole picture.
- 02
The direction
One screen for the plan. Everything else moved behind it.
- 03
The design
Keyboard-first interactions, designed around how dispatchers already worked.
- 04
The engineering
Event-sourced routes, so any plan can be rewound and audited.
- 05
The result
A product real users run their day on, rolled out with no parallel spreadsheets.
Gallery
Look closer
Explore project details, deliverables and outcomes.
Services
What we build
Four areas of work. Most projects touch more than one.
React · TypeScript · Postgres
React Native · Swift · Kotlin
Retrieval · Evals · Guardrails
Go · Node · AWS · Terraform
Products
Software we build for ourselves.
Alongside client work, Brevalen develops its own tools - products that come out of problems we kept running into on real engineering teams.
01 - Open source
Project DNA
The living intelligence layer for software.
Project DNA is a software intelligence engine that understands what a repository is, not just what it contains. It turns raw source code into structured, queryable, evolving knowledge - architecture, business domains, capabilities, health, risk and history - through deterministic analysis.
- Deterministic
- Static analysis only - no model calls, no cloud dependency, fully offline and reproducible.
- Layered engine
- Scanner, AST parser, dependency resolver and architecture inference feed one synthesis layer.
- Evolving
- Snapshots and diffs track how a codebase's identity drifts, regresses or improves over time.
- Queryable
- A versioned ProjectDNA object: domains, capabilities, health, complexity and risk you can query.
- TypeScript
- Monorepo
- SQLite
- Graphology
- VS Code extension
Why Brevalen
Good software is felt in the details.
01
Clarity
Remove complexity before adding complexity. Most product problems are decision problems.
02
Craft
Every interaction deserves attention - empty states, latency, keyboard paths, the second visit.
03
Engineering
The system should be as thoughtful as the interface.
04
Partnership
Build alongside people, not just for them. We'll tell you when we disagree.
Approach
How we work
- Understand
- Define
- Design
- Build
- Refine
- 01
Understand
We learn the problem, the users and the business context before proposing anything.
- 02
Define
We turn ambiguity into a clear product direction, written down and agreed on.
- 03
Design
We design the experience before over-engineering the solution.
- 04
Build
We engineer carefully and iteratively, in production from early on.
- 05
Refine
We test, measure and keep improving after launch.
We keep the loop short: a working build every week, a decision log you can read, and no phase that ends in a slide deck.
Technology
Built for the real world.
We choose tools our clients' teams can still maintain in three years - and we design the whole stack, not just the surface.
Experience
Interfaces, design systems, accessibility
Application
Product logic, state, integrations
Services
APIs, jobs, events, authorisation
Data
Postgres, analytics stores, modelling
Infrastructure
Cloud, pipelines, observability
Each layer is designed to be readable on its own. No hidden magic, no framework that only one person understands.
Frontend
TypeScript · React · Next.js · Tailwind
Backend
Go · Node.js · Python
Cloud
AWS · Cloudflare · Terraform
Mobile
React Native · Swift · Kotlin
AI
Retrieval · Evaluations · Structured output
Data
Postgres · ClickHouse · dbt
Infrastructure
Docker · CI/CD · Observability
About
A small team that would rather ship one good thing.
Brevalen is a product and engineering studio. Designers and engineers work in the same room on the same problem, which is why our interfaces and our systems tend to agree with each other.
We like problems where the domain is messy and the software has to make it feel simple: operations tools, financial workflows, logistics, anything with real users who spend their working day inside the product.
We take a small number of projects at a time. We say no often. When we take something on, we treat it as ours — including the parts nobody enjoys, like migrations, access control and the third round of edge cases.
We are not interested in being the biggest studio. We are interested in the software still being good two years after launch.
The best software doesn't ask to be noticed.
It simply makes difficult things feel easier.
Questions
The things people ask first.
If something here is not answered, write to us - a direct answer beats a proposal deck.
With a short written brief and one conversation. If the problem is a fit, we scope a first phase with a fixed shape - outcomes, milestones and what we will not do - before any contract.
Small on purpose. We take on four clients at a time so the people who scope the work are the people who write the code. No account layer, no handover to a junior bench.
Often. A good share of our work is stabilising and extending systems other people built. We start by reading, measuring and writing tests before we change anything load-bearing.
You get a documented, tested codebase and a walkthrough with your own engineers. We stay on a light retainer only when it genuinely helps - never as a dependency we designed in.
Yes. Interface design, interaction detail and the system behind them are one job here, not three vendors negotiating with each other.
Contact
Have something worth building?
Tell us what you're working on. We'll figure out the next step together - even if that step isn't us.