Custom applications

It's yours: code, data and keys

What we build for you is yours by contract, not under a licence to use. We hand over the source code, the instructions to rebuild the environment from scratch and the credentials for everything needed to run it. Without the last two the code alone is worth little, which is why they are delivered together.

The data stays yours and readable too: PostgreSQL, open formats, no obscure structure requiring our software to interpret it. The day you want to take everything elsewhere, that day should cost you days, not months.

It runs where you decide: on your servers, in colocation, on a private cloud or a public one. There is no piece of ours on the critical path, and no per-user fee growing as the company grows.

Software that is only yours, not a product to adapt to

The substantial difference from a subscription system is that nobody else shares that software with you: no compromises with other customers' needs, no updates changing your screens on a Tuesday morning, no price list deciding what you may do.

In exchange there is a responsibility worth stating: software of your own has to be maintained. Someone must update, fix and evolve it, and that someone must be chosen and paid. It is the bargain that makes ownership sustainable, and it is better made explicit at the start than discovered in year two.

If the platform serves several companies

Some projects don't end inside your company: they serve your branches, your partners or your customers, each with their own data. That is a different case from bespoke software for a single organisation, and it changes one thing in particular.

There the real question is not how the client list looks, but what happens the day a query forgets the company filter. If the check lives only in the code, that day one customer sees another's data and nobody notices: no error, no alert, just extra rows on a screen.

So when a project is of that kind, isolation goes inside PostgreSQL as row-level rules, and the application connects with a role that cannot bypass them. Code can be wrong; the database cannot. If instead the software is for you alone, this layer isn't needed and we don't add it: complexity that doesn't pay.

Fast from the first paint, in every language

Pages arrive already rendered from the server: it matters for the reader, who sees them at once, and for Google, which doesn't run JavaScript. The browser only takes over the parts that genuinely need to react.

Multilingual is structure, not translation bolted on: clean addresses per language, reciprocal links between versions and an explicit decision about what to show when a translation is missing.

One slice at a time, in people's hands

We don't deliver at the end of the project: we deliver pieces someone uses while the rest is still being built. Every slice is a complete function — not a pretty screen with nothing behind it — and it goes into the hands of whoever will actually use it.

It exists to catch, in time, the thing no analysis finds: that a feature requested with conviction turns out, once tried, not to be needed. Noticing that in week three is far cheaper than at final acceptance.

Before that, where the answer is uncertain, we build a clickable prototype: something to touch and argue about while changing your mind costs an afternoon instead of two weeks.

What breaks, and how we find out before you do

Every path that matters — signing in, ordering, paying — is covered by automated checks that run on every change and block the release when something doesn't add up. It isn't perfectionism: it is what lets you fix one thing without fearing you have broken another.

In production, errors reach us with the context of what the user was doing, not as a generic report. The practical difference is that a problem gets fixed the same day instead of after the third phone call.

Performance is measured on real devices, not on a developer's laptop: a page that opens in two seconds on your customer's phone is worth more than any theoretical optimisation.

Not depending on us

The technologies we use are widespread on purpose: if one day you want to change supplier, you will find people who can work on it without months of training. It is the opposite of what suits us in the short term, and the reason you can trust the rest.

Every structural choice leaves its reasoning written down — not a manual, two paragraphs. That is what lets you change your mind three years later knowing what you are touching, and lets another supplier understand the system in a day.

No piece should be understandable by one person only. If a project contains a part only its author can run, that part is your problem even when the code is yours.

For the people working away from a desk

The mobile app is the edge of the system: the point where data is born. If it is comfortable there, everything downstream works; if it is awkward, people go back to paper and the ERP tells a false story.

It has to survive gloves, sunlight, hurry and one free hand: few taps for the most frequent action, large type, clear confirmations. One codebase for iOS and Android, and where value or identity is involved, credentials stay inside the device's secure enclave.