We do not build brochure sites, landing pages or catalogues — agencies do that well and cheaply. We build the complex web systems companies operate on: hundreds of screens, real domain logic, millions of live rows, permissions that an auditor reads, and integrations with the systems you already have.
Twelve years, 200+ web systems in production, the largest at 600+ screens and 40k concurrent sessions. Have a task or a problem you need solved? Send it over, whatever its size — a great many of our clients arrived with something small and stayed for years. You get an answer within 24 hours.
web systems shipped and running
screens in the largest single platform
concurrent sessions at peak
years on systems, not on sites
Not something the marketing department updates twice a year — the platform an operations team has open on the second monitor from nine to six, and that the company cannot trade without.
The system that replaces forty spreadsheets, three access databases and a legacy client nobody can install any more — orders, resources, planning, documents, in one place.
Core · daily use
Self-service for your customers and partners: contracts, orders, balances, documents and support, wired straight into the systems that hold the real data.
External · integrated
Two or more sides, matching and search at catalogue scale, payments and payouts, disputes, ratings and the operational back office that actually runs it.
Scale · money flow
Dispatch boards, monitoring walls, trading and booking screens where the state changes under the user and two people must never take the same job.
Sub-second · concurrent
Multi-step processes with roles, four-eyes approval, SLA clocks, versioned documents and a complete history of who did what and when.
Stateful · auditable
Tables of millions of rows that stay responsive, bulk editing, configurators, planners, schedule grids and editors — the screens that make a generic admin panel collapse.
Volume · interaction
Taking a fifteen-year-old system out of service without stopping the business: dual-run, reconciled migration, staged cut-over and a rollback path at every step.
Zero-downtime cut-over
The build that stalled, the platform two teams have already quoted, or the idea everyone says is too complex. Two weeks, fixed fee, one real workflow running on your data.
Bring it to us
What we deliberately do not do: brochure sites, landing pages, template catalogues and visual redesigns with no system behind them. A good agency will do those faster and for a tenth of our price, and we will tell you so in the first reply rather than take the work.
Both are “a website” to a procurement form, and they have almost nothing in common. Everything on the right is why complex platforms are quoted by developer-months and still fail — and it is the only kind of work we take.
If your project sits on the right-hand column, the price is set by the domain and the data you already have — not by the number of pages. That is why we start with a paid pilot on one real workflow instead of an estimate written from a specification document.
Complex builds rarely fail on the framework choice. They fail on the same six things, usually somewhere between month four and the first real user. Here is all six, and what we do about each.
The specification describes the process as management believes it works. The actual rules — the exceptions, the informal approvals, the three cases that carry the margin — live with the people doing the job and surface at acceptance.
What we doWe model the domain with the people who operate it: states, transitions and edge cases agreed in week one, before a single screen is designed.
Fifteen years of records with duplicates, three encodings, fields reused for a different meaning in 2019, and a business that cannot pause for a weekend cut-over.
What we doMigration as engineering: profiling, mapping, dual-run against the old system, reconciled totals, staged cut-over and a rollback path at every step.
“Managers see their own region, except the group head, except during audit.” Retro-fitting that into a system built for one kind of user is a rewrite of every query and every screen.
What we doThe permission model is designed first and tested like business logic: roles, row-level rules, delegation, impersonation and a complete audit trail.
Dispatchers taking the same job, a stock level that goes negative, an approval applied to a document that changed underneath. Under real load these stop being rare.
What we doTransactional boundaries, locking and conflict resolution designed explicitly, with live updates pushed to open screens rather than discovered on refresh.
A screen built against 5 000 test rows meets two million real ones, a report locks the database at month-end, and the interface everyone lives in becomes the thing everyone complains about.
What we doVolume is a design input: query and index design, server-side pagination and virtualised grids, caching, background jobs and measured p95 budgets per screen.
No tests, no types, no documentation, environments configured by hand, and one developer who knows why any of it works. Every change becomes a negotiation and eventually a rewrite.
What we doTyped code, automated tests, infrastructure as code, migrations and runbooks — built so the platform can still be extended in year eight, not just shipped in year one.
One team covers product design, frontend, backend, data, integrations and infrastructure — so nobody is waiting on a subcontractor to explain why the numbers on two screens disagree. Stack is chosen per project; these are the parts we own.
The integration side is the same engineering our automation practice does every day: where a system has no API we go through its database, its files, its protocol or a purpose-built adapter. “There is no integration for that” is not an answer we give.
A platform is easy to make fast when it holds test data and one user. The engineering is in holding response time on real history, at peak concurrency, while a release ships every week and nothing goes down.
Operating envelope
Volume, concurrency, latency budget and release cadence are agreed on day one and written into the SLA — not discovered in month four when a grid takes eleven seconds to open and the operations team quietly goes back to the spreadsheet.
Where the load goes
Illustrative profile of one production platform. Your envelope is fixed in the design phase and written into the SLA.
Every platform we ship runs on the same contour. Blocks change per product; the property that does not change is that a release is boring — tested, reversible, migrated without downtime, and observable from the first minute it is live.
The difference between a web studio and a systems engineering team shows up at the second release train — when the domain turns out to be deeper than the brief, and the data you already own turns out to be the hard part.
The first two weeks are spent with the people who do the work: what the states are, what may follow what, who is allowed to override, what happens on the third of the month, and which exceptions carry the money. Interfaces designed after that stay stable; interfaces designed before it get redrawn twice and blow the estimate.
Most complex builds are replacements, and the schedule is decided by fifteen years of existing records rather than by the new features. We profile and map that data early, run the new system in parallel with the old, reconcile the totals daily and cut over in stages — so the business never has a week of two truths.
Systems people spend eight hours a day in are judged on the twentieth click, not the first screenshot. Keyboard-first flows, dense grids that stay responsive on millions of rows, bulk actions, undo, and states that survive a lost connection — this is where a generic admin framework stops and product engineering starts.
Typed code, automated tests, infrastructure as code, migrations, runbooks and architecture notes. Shipping is the start of it, not the end: hosting, monitoring, on-call, upstream changes, tuning and new features all sit inside one monthly arrangement, handled by the same engineers who designed the thing. A system we will still be running in year eight has to be engineered to be operated, not merely delivered — and most of our clients are on their third or fourth system with us.
A platform an operations team lives in is a production system with an uptime, not a project that was delivered once. These are the commitments in the support agreement; tiers and windows are set per project against how critical the system is.
| Commitment | Target | What it means in practice |
|---|---|---|
Availability |
99.9 % | Measured on real user requests, not on a ping to the home page, and reported monthly. You get the same dashboard we watch. |
Response time |
< 200 ms p95 | A latency budget per key screen, held against production data volumes. A slow grid is treated as a defect with an owner, not as the price of having a lot of data. |
Releases |
Weekly+ | Automated tests, staged rollout, zero-downtime migrations and a rollback path. Shipping on a Thursday afternoon is routine rather than an event. |
Monitoring |
24 / 7 | Errors, latency regressions, failed jobs, queue growth and integration outages are detected by us and raised to you — not reported by a user on a Monday morning. |
Engineering response |
From 4 h | Incident tiers with named windows. A changed partner API, a new role, a schema migration or a security patch is routine work covered by the retainer, not a change request. |
Security |
Continuous | Dependency patching, access reviews, full audit trail and a codebase that stands up to a client's penetration test — several of ours have. |
Each of these came to us after an agency delivered screens without a domain, an internal team ran out of runway, or a vendor returned the migration as impossible. Clients are under NDA — the engineering detail we walk through against your own case.
Orders, capacity planning, subcontractors, documents and settlement for a freight group of 3 000 staff, live in nine countries.
What was hardFifteen years of data in a system with no export, per-country process differences, and a business that could not be paused for a cut-over weekend.
Self-service for corporate clients: balances, payments, limits, documents and approvals, wired into a core banking system and three payment providers.
What was hardIdempotent money movement, a permission matrix the regulator reads, full audit of every action, and a core system that answers in seconds rather than milliseconds.
Live matching, dispatch board, pricing, payouts and dispute handling, with an operations back office running the whole thing from one screen.
What was hardThousands of dispatchers and couriers acting on the same objects at once, sub-second state propagation, and a previous build that double-assigned jobs under load.
On a complex system, an estimate written from a specification is a guess — the gap between the documented process and the actual one is routinely tenfold. So we build one slice on your real data and your real systems first, for a fixed fee.
1Brief
What the system must run, who works in it, which systems it must talk to, what the existing data looks like and what happens to the business if it works. Scope often narrows here.
OutputDomain map & risk profile
2Pilot
Two to four weeks: a real workflow running against your real data and at least one real integration — plus the honest list of what the legacy data and the domain are going to cost.
OutputWorking slice + risk list
3Design
Domain model, permission model, integration contracts, migration plan, performance budgets, release cadence and price — written into the contract, not into a slide.
OutputFixed scope & fixed price
4Build
Every week ships something usable in your environment, with real users on it early. Monitoring, runbooks and documentation are built alongside it, not bolted on at the end.
OutputA system running in production
5Operate
On-call, monitoring, integration changes, new modules and onboarding of your own developers — routine work sits in the retainer, large additions are quoted first.
OutputA platform you could run without us
Complex platforms price by domain depth, the state of your existing data and the number of systems that must agree — not by page count. So we price in two steps, and we say no early when the work is not ours.
Model
You start on whichever rung fits, and most clients start with one small first task. From the Operate rung onward it is a single monthly arrangement covering hosting, monitoring, on-call and continued development, so nobody on your side has to build an operations team around it. Infrastructure runs on ours or inside your own perimeter — whichever your security and finance people prefer.
Not our work
If your project is real but not our kind of work, we will say so in the first reply and point you at someone better suited — including an off-the-shelf product when that is genuinely the right answer. That costs us nothing and saves you a quarter.
Legal & governance
Platforms run inside the client's own perimeter, authenticate against the client's identity provider, and enforce role- and row-level access with a complete audit trail of who saw and changed what. Personal data is minimised by design, and retention and deletion are features rather than promises.
GDPR alignment and internal-control requirements are implemented through technical and organisational controls, and our code is written to survive a client-commissioned penetration test. Confirming the lawful basis, the retention rules and the regulatory treatment for a specific system and jurisdiction remains with the client’s legal and risk teams — we give them the documentation to do it.
If yours isn’t here, put it in the form — we answer in writing, within 24 hours, and without a discovery call first. Most questions get a straight yes or no rather than a proposal.
Bring us the hard system
Send the process it has to carry, the systems it must talk to and the data that already exists. You get a straight answer: whether it can be built, what specifically makes it hard in your case, and roughly what it costs to build and to run. No deck, no discovery call before there is anything to discover.