Internal tools for work that does not fit a template

Most projects start with the screens because screens are visible. We start with whatever will be genuinely difficult — the money changing hands, the state machine an order moves through, the rule nobody can state out loud yet. On the operations platform that was made-to-order production: every item is built for one person from measurements a scanner takes, and the system has to hold that thread from the first appointment through manufacturing, delivery and a remake eighteen months later. Twenty-one data models exist because that thread does. If the hard part is left until week six, everything built before it gets rewritten around it.

We do not send a figure on its own. You get the number, the scope it covers, and the list of things we assumed to arrive at it — because that list is where estimates actually go wrong, not the arithmetic. If an assumption turns out false in week two, we say so then, with what it costs, rather than absorbing it quietly and running out of road in week seven. This is also why the price on this page is tied to a named first version rather than to hours: hourly rates get compared line by line and the conversation becomes about the rate instead of the result.

A two-sided marketplace, a CRM built around your pipeline, a portal your customers log into: each is a web application, and each arrives with a hard part we already know — the money between two strangers, the rules about who may move a deal where, the access that decides who sees whose documents. When your project is one of those shapes, start on its page instead of this one: the scope and the number there are for that shape rather than for web development in general.

The repository is yours, in your organisation. The domain and the servers are in your accounts, paid by you, and we work as invited guests. There is no agency licence, no runtime that stops when the invoice does, and no hosting reseller margin. At the end we walk your developer — or the one you hire next — through the code and the deployment, and leave a runbook written against your system. The test we care about: could another team take this over next month without calling us? If not, we built it wrong.

From week one there is a staging address you can open. Not a screenshot in a status report, not a demo we drive — a link, on your phone, at any hour. Every push builds and deploys itself, and the tests on the paths that carry money run before it lands. That is what makes the eight weeks checkable rather than a promise: you are not waiting for a reveal, you are watching a thing become itself, and you can stop us in week three if it is going somewhere wrong.

Backups that have actually been restored once. Errors that reach a person instead of a log nobody opens. A second pair of hands who can deploy. Data you can export in a format another system can read — because the honest test of ownership is whether you could leave us. None of it demos well, all of it is why a system is still standing in year three. It is included, and it is deliberately unglamorous.