Services
What we build,
in detail.
Six things we do well, and the deliverables you can expect from each. If your problem doesn't fit cleanly into one of these, talk to us anyway. We'll be honest about whether we're the right team.
Custom SaaS builds.
Greenfield products from spec to production. We sit with you to scope the thing properly, design the data model and the workflows, then build and ship. The output is a live product, a clean codebase, and documentation a human can actually read.
We work in tight feedback loops. Demoable progress every week or two, never a six-month black box. You see the product taking shape, you push back on the bits that aren't right, and we course-correct before they become expensive to fix.
What you get
- Production-ready web app deployed on infrastructure you own.
- Clean, documented codebase in TypeScript or Rust, with a README a new engineer can follow.
- Auth, billing, admin tools wired up properly from day one.
- CI/CD pipeline with automated tests and one-click deploys.
- Handover sessions so your team can take it forward without us.
- 30 days of bug-fix support after launch, no extra charge.
Data pipelines and infra.
Ingestion, validation, routing, reporting. The systems that have to keep running when nobody's looking. We've shipped pipelines that move millions of records a day, queues that survive bad days at upstream providers, and analytics that answer questions across billions of rows in under a second.
ClickHouse, Postgres, Kafka, NATS, Redis. We pick the boring, proven tool that fits the shape of your data, not whatever's trending on Hacker News this month. If your existing pipeline is the problem, we can audit it first and tell you exactly where it's losing money.
What you get
- End-to-end pipeline from source ingestion through to analytics and reporting.
- Schema and data model designed for the queries you'll actually run.
- Backfill and replay tooling so you can reprocess history without downtime.
- Observability with metrics, alerts, and dashboards out of the box.
- Runbooks for the three or four failure modes that actually happen.
- Load tests at the throughput you need, not the throughput we hope you'll need.
Desktop and mobile apps.
Native-feeling apps for Windows, macOS, iOS, and Android. We build cross-platform with Tauri or Capacitor where it makes sense, and reach for Swift or Kotlin when the platform features demand it. Offline-first storage, OS keyring integration, push notifications, file system access, the things web apps quietly can't do.
We also ship apps to the App Store and Play Store for clients who don't want to maintain their own developer accounts and signing infrastructure. That side of things is finicky, slow, and easy to get wrong. We've done it enough times that it isn't.
What you get
- Signed, notarised builds for macOS and Windows, ready to distribute.
- iOS and Android apps submitted and approved on your developer accounts.
- Auto-update pipeline so users always have the current build.
- Native integrations for keyring, push, biometrics, and file system access.
- Offline-first sync layer with conflict resolution that won't lose data.
- Crash reporting wired up so the first you hear about a bug isn't from a user.
Rescue projects.
Inherited a codebase that's on fire? An offshore build that didn't deliver? A founder-built MVP that can't scale past its first few customers? We take on rewrites, rebuilds, and salvage jobs. Honest assessment first, then a plan to get you shipping again.
Sometimes the right answer is to throw it away and start over. Sometimes it's a six-week stabilisation pass. We'll tell you which one before we start work, and we'll tell you why. No drama, no hand-wringing, no billable hours spent making the existing team feel bad.
What you get
- Written technical audit with findings, risks, and a prioritised fix list.
- Build-vs-rewrite recommendation with honest cost and timeline estimates.
- Stabilisation work to stop the bleeding before the rebuild begins.
- Migration plan for users, data, and integrations with zero downtime.
- Rebuild or refactor delivered in the same engagement, no second sales cycle.
- Knowledge transfer so your existing team can carry on once we're done.
Compliance-heavy systems.
Audit logs, role-based access control, encryption at rest and in transit, data residency, customer-managed keys. The boring controls that auditors and procurement teams actually care about. Built into the product from day one, not bolted on three weeks before the SOC 2 audit.
We've shipped systems that pass enterprise procurement reviews, hold up under ISO 27001 audits, and satisfy GDPR data residency requirements without resorting to creative interpretations. If you're selling to regulated industries or large enterprises, this is the difference between a six-month sales cycle and an eighteen-month one.
What you get
- Tamper-evident audit logs covering every privileged action.
- Role-based access control with a permission model that scales past five users.
- Encryption at rest and in transit, with optional customer-managed keys.
- Data residency controls so regulated data stays where it has to stay.
- SSO and SCIM integration for enterprise buyers who insist on it.
- Audit-ready documentation for your security questionnaires and review calls.
Fractional CTO.
One day a week or one week a month, on retainer. Architecture reviews, hiring help, code review for your in-house team, technical due diligence for fundraising, vendor selection, on-call coverage for the bits you don't want to staff up for yet. For founders and small teams that need a second senior brain without committing to a full-time hire.
This isn't a coaching engagement and it isn't advisory hours. We do the work alongside your team, in your codebase, in your Slack, in your incidents. We just do it part-time, and we don't expect equity unless you've thought hard about it and want to.
What you get
- Architecture and technology decisions made with a senior engineer in the room.
- Hiring support from job specs through to technical interviews and offers.
- Code review on critical pull requests, with feedback your team can learn from.
- Incident response coverage for the hours you don't have staffed yet.
- Investor and customer-facing technical conversations, attended in person or on Zoom.
- Quarterly technical roadmap reviewed against the business plan, not in a vacuum.
Process
How we run an engagement.
Every project moves through the same four phases. We don't pretend to be agile, and we don't pretend to be waterfall. We're senior engineers doing the obvious thing.
Discover.
A scoping call, then a paid discovery sprint. We map the problem, the data, the constraints, and the people. Output is a written brief you can take to anyone else if you'd rather.
Design.
Architecture diagrams, data models, key user flows, and a written delivery plan with milestones. We agree on the trade-offs before we write production code, not after.
Build.
Two-week cycles with a working demo at the end of each one. Weekly written updates. Slack channel for day-to-day questions. No surprises in the monthly invoice.
Hand over.
Written runbooks, walkthrough sessions for your team, and 30 days of bug-fix support included. We want you to stop needing us, not to lock you in.
FAQ
Common questions, answered honestly.
Is there a minimum project size?
Yes. Our smallest fixed-scope engagements are around six weeks of senior engineering time, which works out at roughly forty thousand pounds. Below that, the discovery and handover overhead eats too much of the budget for either of us to be happy with the result. For shorter pieces of work we usually point people at our fractional CTO retainer instead.
How do you bill, and what are the payment terms?
Fixed-scope builds are quoted as a single price with three milestone payments: thirty percent on signature, forty percent at the agreed midpoint demo, and thirty percent on hand over. Retainers are billed monthly in advance. We invoice in GBP, net fourteen days, by bank transfer. We don't take credit cards and we don't use escrow services.
Where is the team based, and how do you work?
The studio is registered in England and Wales. The team is fully remote across the UK and Ireland, with overlapping working hours that map cleanly onto European and East Coast US time zones. We can come to you for kick-off and key reviews when it's useful, but most of the work happens in async writing and weekly video calls. We don't subcontract to anyone outside the team.
Who owns the code we write?
You do. Everything we produce on your engagement is yours under standard work-for-hire terms, transferred on final payment. The one carve-out is our internal library of generic utilities, things like our logging wrapper or our test harness scaffolding, which we license back to you perpetually and royalty-free. You can audit what's in it before signing. We don't keep any code, secrets, or credentials after hand over.
Will you take equity instead of cash?
Almost never. Equity is the wrong incentive for a build relationship, and it pushes us to over-engineer for a future that might not arrive. We'd rather be paid for the work we do and let you keep the upside. The one exception is the occasional very early-stage engagement where we know the founders well and the cap table makes sense, in which case we'll discount cash in exchange for a small equity slice that vests over the work.
Got something
boring to build?
A 30-minute scoping call, no pitch deck. We'll tell you honestly whether we're the right fit.