Services
Design, engineering, and everything after launch.
Most agencies hand you a design file or a repository and walk away. We take a product from first conversation to production — and stay on to keep it running.
Websites
Marketing sites, e-commerce, and content platforms that load fast, rank well, and turn visitors into customers.
- Typical timeline
- 4–10 weeks, depending on page count and whether e-commerce is in scope.
- Best fit
- Best when your current site is slow, hard to update, or no longer matches where the business has moved.
A website is usually the first thing a customer meets, and most of them are slower, harder to edit, and worse on a phone than their owners realise. We build sites that render in well under a second on a mid-range Android over 4G, because that is the device most of your traffic is actually using.
Everything is built on a component system, so pages stay visually consistent as the site grows and your team can assemble new ones without design drift. Content lives in a CMS your marketers control — we do not want to be a bottleneck between you and your own copy.
What's included
- Marketing and brand sites, landing pages, and campaign microsites
- E-commerce storefronts, product catalogues, cart, and checkout
- Headless CMS setup and editor training, so your team publishes without us
- Technical SEO: metadata, structured data, sitemaps, redirects, canonicals
- Core Web Vitals work — image pipeline, font loading, bundle budgets
- Analytics, consent management, and conversion tracking
- WCAG 2.1 AA accessibility built in from the first component, not retrofitted
What you get at handover
- Production site on your own hosting and domain
- Component library and page templates your team can reuse
- CMS with editor accounts, roles, and a written publishing guide
- Lighthouse and accessibility audit reports at handover
Web applications & SaaS
Full-stack products — the dashboard your customers log into, and everything holding it up.
- Typical timeline
- 8 weeks for a focused MVP; 3–6 months for a full platform.
- Best fit
- Best when you are building something customers log into and pay for, and it needs to survive its second year.
This is the work that decides whether a product survives contact with real users. Authentication that holds under scrutiny, permissions that do not leak data between tenants, billing that reconciles with your accounts, and a deploy pipeline nobody is afraid to run on a Friday.
We design the data model and the interface together, early, because the two constrain each other and discovering that in month three is expensive. You get a staging environment and repository access from the first week, so you are watching the product take shape rather than waiting for a reveal.
What's included
- Customer portals, dashboards, internal admin, and back-office tools
- Authentication, SSO, role-based permissions, and multi-tenancy
- Subscriptions, metered billing, invoicing, and payment provider integration
- REST and GraphQL APIs, webhooks, and third-party integrations
- Data modelling, migrations, and reporting queries
- Cloud infrastructure, CI/CD, staging environments, and preview deploys
- Monitoring, error tracking, structured logging, and automated backups
What you get at handover
- Production and staging environments in your own cloud accounts
- Repository you own outright, with CI and a documented deploy process
- Architecture notes, data model documentation, and a runbook
- Test suite covering the paths where failure would actually cost you
Mobile applications
iOS and Android apps from one codebase, shipped to the stores and maintained after launch.
- Typical timeline
- 10–16 weeks to first store release, including review time.
- Best fit
- Best when your product needs to live on a home screen — notifications, offline use, or device features the browser cannot reach.
Shipping a mobile app is two jobs: building it, and getting it through review. We do both. One codebase covers iOS and Android, which keeps the cost of a second platform close to zero and stops the two versions drifting apart over time.
Mobile has constraints the web does not — patchy connectivity, background limits, store policy, and users who will not tolerate a spinner. We design for offline first where it matters, and we handle the store submissions, review responses, and the release cadence afterwards.
What's included
- Cross-platform builds for iOS and Android from a single codebase
- Offline support, background sync, push notifications, and deep links
- Device features: camera, location, biometrics, and file handling
- In-app purchases, subscriptions, and mobile payment flows
- App Store and Play Store submission, review responses, and store listings
- Over-the-air updates for changes that do not need a store review
- Crash reporting, analytics, and staged rollouts
What you get at handover
- Published apps on both stores under your own developer accounts
- Signing keys, certificates, and store credentials handed to you
- Automated build pipeline producing installable test builds
- Release checklist and rollback procedure
AI integration & automation
AI that does real work inside your product — not a chat box bolted onto the homepage.
- Typical timeline
- 3–6 weeks for a scoped feature; longer for multi-step agents.
- Best fit
- Best when you have a real workflow that is slow or manual, and data the model can ground itself in.
Most AI features fail for the same two reasons: the model cannot see the right data, and nobody defined what a correct answer looks like. We start with the second problem. Before writing anything, we agree on what the feature must get right, and how we will measure it.
Then we build the retrieval layer that gives the model your actual documents, tickets, or records, with the permissions of the person asking. We add guardrails, cost controls, and an evaluation suite so you can change models later without guessing whether quality moved.
What's included
- Assistants and agents embedded in your product's real workflows
- Retrieval over your own documents, records, and knowledge base
- Back-office automation: triage, classification, extraction, summarisation
- Evaluation suites, so you can measure quality instead of eyeballing it
- Guardrails, prompt-injection defences, and permission-aware retrieval
- Token cost monitoring, caching, and model routing to control spend
- Honest scoping — we will tell you when a rules engine beats a model
What you get at handover
- Working feature in production behind a flag you control
- Evaluation suite with a baseline score you can regression-test against
- Cost model showing spend per user and per request
- Documentation covering prompts, retrieval sources, and failure modes
Operate & manage
We run the product after it launches — the infrastructure, the releases, and the roadmap — so you can run the business.
- Typical timeline
- Ongoing, month to month. Two-week handover if you take it in-house.
- Best fit
- Best when the product is live and mattering, and you would rather not build an internal platform team to keep it that way.
Launching is the beginning. Someone has to watch the error rate, renew the certificates, patch the dependency with the CVE, restore the database when a migration goes wrong at 2am, and decide which of the forty things in the backlog ships next month. Most teams do not want to hire three people to cover that.
So we keep operating what we build — or take over something you already have. You get a named team that already knows the codebase, a monthly report you can actually read, and a roadmap we work through together. Nothing is a black box: the accounts stay in your name, the documentation stays current, and you can end the arrangement and take everything with you.
What's included
- Uptime monitoring, alerting, and an on-call path for real incidents
- Dependency updates, security patching, and vulnerability triage
- Backups, restore drills, and disaster-recovery procedures you can test
- Release management — deploys, feature flags, staged rollouts, rollbacks
- Roadmap and backlog management, with priorities agreed each month
- Performance and cost tuning as usage and cloud bills grow
- Analytics review and reporting on what users actually do
- Second-line support for issues your own team escalates
What you get at handover
- Monthly report: uptime, incidents, work shipped, and what is next
- Runbook and incident log kept current, not written once and forgotten
- Agreed response times for outages and urgent issues
- Clean exit whenever you want it — credentials, docs, and handover
How we build
Dynamic technology, carefully chosen.
We work in TypeScript across the stack — React and Next.js on the front end, Node on the back, Postgres for data, and cloud platforms that scale without a devops department.
None of that is precious. If your team already runs on something else, we work in your stack rather than making you adopt ours. The goal is software your developers can pick up after we hand it over — which rules out anything clever enough to need us to explain it.
Every project ships with documentation, tests where they earn their keep, and a repository you own outright from the first commit. Accounts are created in your name, not ours, so nothing about your product depends on our continued goodwill.
Ways to work together
Three ways in.
Project build
A defined scope, a fixed timeline, and a fixed price.
We run a paid discovery first — usually one to two weeks — and come out of it with a specification, a plan, and a number. From there the price does not move unless you change the scope, and we tell you before it does.
- Fixed price agreed before build starts
- Weekly demo of working software
- 30 days of post-launch fixes included
Best when: You know what you need and want it delivered.
Ongoing partner
A monthly retainer covering design, engineering, and maintenance.
You get a set amount of our capacity each month and a roadmap we agree together. Priorities can move week to week — that is the point. Most clients start here after a project build, when the product is live and the backlog keeps growing.
- Agreed capacity each month, rolled over within the quarter
- Dependency updates, security patches, and monitoring included
- Named contact who already knows your codebase
Best when: The roadmap keeps moving and you want a team that stays.
Rescue & rebuild
Something is half-built, inherited, or falling over.
We start with a fixed-price audit: what the code does, what is dangerous, what can be saved, and what it would cost to finish versus rebuild. You get that assessment as a document you own, whether or not you continue with us.
- Fixed-price audit with a written assessment
- Stabilisation first — stop the bleeding before adding features
- Honest rebuild-versus-repair recommendation
Best when: You have inherited a codebase, or a previous team left mid-project.