Measure this visit?
Accept allows Google Analytics, Microsoft Clarity and PostHog, including session recording. Reject stops their recording. Cookieless counts and server request logs stay on. What we measure
Our practice
Six engineering services under one team: the product, the public site, automations, AI features, governed agents and trading bots. Shipped as code.
Updated
Nothing bought on this page will bring one extra person to your product. Demand is not here. Campaigns, rankings, citations and testing on pages that already exist belong to the growth and visibility hubs, and they answer to different numbers. The measure on this side is narrow: software in production, used by the people it was built for.
Six services sit under this hub and they end the same way. Pull requests in your repository, reviewed by your engineers, running in your production environment. What separates them is who the software is for.
Which of the six you are buying is rarely obvious from the brief. A brief that is currently one sentence usually holds two or three separate projects. “We want to add AI to the product”. “The app needs rebuilding”. Each has its own buyer and its own way of going wrong.
Prising them apart is the first thing that happens here, before anything is costed. Skip that step and one budget funds whichever piece is the most interesting to build. It gets measured against a number chosen for a different project.
Three of those have AI in the name and they are not interchangeable. The dividing question is who touches the output: your staff, your customers, or nobody, because the system acted on its own.
One case routes out of this hub entirely. It covers a prototype an AI coding tool already wrote, where the job is security, hardening and getting it live, not building it again. That is vibe-coded app launch, over in growth.
The normal arrangement is two suppliers. One writes the software, one sells it, and the decisions that matter most fall in the gap between them. The gap is where you get a product with no linkable URLs and with documentation behind a login. It is also where no event stream tells you which channel produced a customer who stayed.
We do not have that gap, because there is no second firm. The people who will have to generate demand for the thing sit in the build review, while the decisions are still cheap to change. That is the whole argument for this line existing. It is also the part that makes us accountable. When a product ships and cannot be sold, there is nobody else in the room to point at.
The engineering standard does not change with the service.
Work arrives as pull requests in your repository and your engineers review them. We work in the stack your team already maintains, where that is workable. No infrastructure gets introduced that nobody there can operate after we leave. Deploys, error tracking and the tests that cover money and permissions exist before feature work starts. Anything we ship emits the events that describe what it did, defined with the people who will have to report on them. And every engagement ends with a runbook, because a system only one supplier can operate is a system you do not really own.
A model where a database query would do the same job, faster, cheaper and with the same answer twice. Putting AI on the invoice is not worth making the output non-deterministic.
Scopes where the deploy path and the instrumentation are what gets cut to fit the budget. If the money only stretches to features, the honest counter-proposal is a smaller system built properly, and that is the one we will make.
“It worked in the demo” as a definition of launched. A demo meets one person who wants it to succeed. Production meets everybody else, at once, on hardware you have not tested.
Any arrangement that parks part of the running system in an account of ours. Leaving should cost you a handover meeting, not a rewrite.
A build where nobody can yet answer “how will we know this worked?”. We decline those. If the answer is still being settled in week three, the scope has no edge. A six-week project then turns into a permanent one by accident.
Most briefs contain two or three projects wearing one name. Separating them early gives each part its own scope and its own measure. Otherwise one budget quietly funds whichever piece is most fun to build.
We write down the condition that ends the project before we write code. Without it, scope grows by a feature a week and nobody can say whether the thing succeeded, because success was never defined.
Deploys, error tracking, and the tests that cover money and permissions come before features. A team that leaves those until the end ships late and then cannot change anything safely, which is the expensive half of the mistake.
Work lands as pull requests your own engineers review. It keeps your team's knowledge of the system current, and it means the day we stop is not the day the code becomes unmaintainable.
The feature ships with the events that report on it and a runbook written for whoever inherits it. We would rather be removable than retained by obscurity.
Because the decisions that make software hard to sell are made during the build, not after it, and by then they are structural. Rendering strategy, URL design, where the login wall sits, whether the product emits events at all. When the same team owns both sides there is no handover meeting where those get lost, and nobody else to blame when they are.
Usually one of three things. A team that is strong and has never done this particular thing before. A build that has to happen alongside keeping the current product alive. A piece nobody internally wants to own. If none of those describe you, keep the money. We will say so on the call, before there is an invoice.
The short version. The application behind your login is software development, and the pages in front of it are web development. Work your own staff repeats is AI automations. A model your customers touch is AI integration. A system that decides its own next step is agentic integrations. Software that trades to your strategy is algorithmic trading. If two of them apply, they are still two engagements with two measures, and we scope them that way. Blurring them into one number helps nobody.
Yes, from the first commit. It lives in your repository, in your organisation, on infrastructure you control, with no runtime dependency on anything of ours. An agency that can only be replaced by rewriting its work has a commercial interest in you never looking too closely.
Often, and we will read it before quoting. A prototype generated by an AI coding tool is a specific case with its own page under growth. The work there is security, hardening and launch, and not a new build. What we will not do is agree to inherit a system, discover it is unworkable, and then bill you to find that out.
On a scope that is genuinely fixed, yes. On a scope still being discovered, a date is a guess wearing a suit. The honest answer is a first slice with a date and a decision point after it. A quarter-long timeline offered in a first call is priced against a system nobody has read yet.
Start a conversation