We build software as if we were going to maintain it for years.

• The problem before the technology

  A good solution starts with a good question. Before proposing an architecture we want to understand what happens today, who suffers it and how we'll know it got better.

• Simple first

  The simplest solution that solves the problem is usually the cheapest to maintain. Complexity comes in when there's a reason, and that reason is written down.

• AI is a tool

  We use it when it improves the result and avoid it when a rule is enough. It's not a sales pitch: it's one more part of the system, to be measured like any other.

• Saying no is judgement too

  If something isn't worth it —a full rewrite, a trendy technology, a scope that doesn't fit the deadline— we say so, even if it means a smaller project.

• You talk to the people who build

  No middlemen between your team and the people writing the code.

• You see the progress

  Demos at the end of every cycle, shared repository and board from day one.

• Bad news arrives early

  A risk flagged in time is a planning problem. Flagged late, it's a crisis.

• What we build is yours

  Code, data, infrastructure and documentation stay in your accounts.

Running what we build makes us live with our decisions: respond when something fails, improve without breaking things and pay the cost of every shortcut.

Ailita looks after user access in multi-company applications. Alfred turns invoices that arrive by email into data for your ERP. What we learn from them reaches every project.

Decisions in writing, automated tests, security by design, systems you can see into and reversible releases. We explain them in detail in How we work.