Skip to content
AI Digital Hub

Product & Growth

Product Engineering

Prototype in weeks, production that survives the first thousand users

  • A working prototype before the specification is finished
  • Production build with the operational surface designed in
  • The same team runs it afterwards, or hands it over properly
3-4 weeks
Clickable prototype under real users

Against real data, not a design mock

10-14 weeks
Prototype to production launch

Typical for a booking or portal build

0
Rewrites between prototype and production

The prototype is built on the production stack

Why this sits next to the AI work

Most of what we are asked to build is not an AI feature. It is a booking engine, a franchise provisioning portal, a ticketing platform or a customer account area — with AI somewhere inside it, doing one specific job.

Treating those as separate disciplines is how you get a good model bolted onto a platform that falls over at launch. The platform is the product. The AI is a component of it, and it should be scoped, built and operated by the people who own the whole thing.

What we actually build

Booking and reservation systems. Availability, holds, group and multi-party bookings, cancellation and refund logic, and the payment flows underneath. The hard part is never the calendar — it is concurrency, partial failures and the states a booking can be in when a payment times out.

Provisioning and multi-tenant platforms. Spinning up a new site, franchise, branch or tenant with its own configuration, branding, users and billing, without a human doing setup by hand each time.

Customer portals and account areas. Self-service that genuinely deflects support volume rather than adding a login page in front of the same phone number.

Commerce and packaging. Catalogues, bundles, subscriptions, upgrades, proration and the reconciliation to finance that nobody scopes until it is missing.

Real-time and high-concurrency surfaces. Live scores, live availability, live inventory — where the interesting engineering is fan-out and cache invalidation rather than the read itself.

The states that decide whether a build is finished

A demo shows the happy path. Production is mostly everything else, and this is the list we work through explicitly rather than discovering under load.

Concurrency. Two people booking the last slot. The hold that expires mid-checkout. The admin editing a package while a customer is buying it.

Payment edge cases. Authorised then failed. Succeeded but the webhook never arrived. Refunded partially. Disputed three weeks later. Each needs a defined system state, not an exception in a log.

Partial failure. The payment worked and the confirmation email did not. The booking saved and the downstream sync did not. Deciding what is authoritative, and how it reconciles, is a design decision made once rather than a bug found repeatedly.

Expiry and time. Holds, sessions, offers, promotional windows and time zones. Every booking system we have inherited has had at least one bug here.

Scale shape. Not average load — the shape. A ticket on-sale, a results announcement and a sale launch are all spikes with different profiles, and the profile is what breaks you.

How this pairs with the rest

Product Engineering is the build rung. Either side of it:

What we will talk you out of

Building what you can buy. If a mature SaaS product covers eighty per cent of your requirement, the honest answer is usually to buy it and integrate the missing twenty, and we will say so even though it is a smaller engagement for us.

The case for building is specific: the process is genuinely how you compete, the integration surface is unusual, the unit economics of per-seat pricing do not work at your volume, or you need to own the data. Where none of those hold, a build is an expensive way to get a worse version of something that already exists.

How it runs

What the engagement looks like

Phases, not a proposal. Each one has an output you can see.

  1. 1

    Frame the product, not the feature list

    Week 1

    What has to be true for this to earn money, and what is the smallest version that tests it. Most briefs arrive as a feature list, and the feature list is rarely the constraint.

  2. 2

    Prototype on the real stack

    Weeks 2-4

    A working build against real data, deployed where users can reach it. Not a design mock and not a throwaway — the prototype is the first commit of the production system, which is why there is no rewrite later.

  3. 3

    Harden into a production build

    Weeks 5-11

    Authentication, payments, admin tooling, the awkward states nobody demos, and the infrastructure to run it. This is the majority of the work and the part most quotes underprice.

  4. 4

    Load test before launch, not after

    Weeks 11-13

    A realistic traffic shape against a production copy, with scale-out latency measured rather than assumed. Launch dates are known in advance; the capacity to survive them should be too.

  5. 5

    Run it or hand it over

    Ongoing

    A managed retainer, or a documented handover with a live exercise where your engineer takes an incident while we watch. Both are fine. Leaving it undocumented in production is not.

FAQ

Questions we get asked

Talk to someone who does product engineering

Thirty minutes with an engineer who has delivered this, not an account manager. You will get a straight answer on feasibility, rough cost and where it would fail.

Or email [email protected] · we reply within 1 business day