Discovery sprint
Two weeks, fixed price. Architecture, plan, risks and a costed roadmap you can take to a board. Yours to keep whether or not you continue with us.
- Fixed fee, fixed dates
- Written technical proposal
- No obligation to proceed
Services
Everything between the idea and production
Five service lines, staffed by the same senior people. Take one, take all five, or take us for the six weeks it needs and no longer.
Web platforms
Customer portals, internal tooling and APIs that hold up under real traffic and real auditors.
Jump toiOS & Android
Native and cross-platform apps, shipped through review, monitored after launch.
Jump toDesktop applications
Windows and macOS software for the work that a browser tab was never going to handle.
Jump toQA & test automation
Regression suites, load tests and release gates that catch things before your customers do.
Jump toDevelopment teams
Embedded senior engineers who join your standups and raise your team's floor.
Jump to
Web platforms
Customer portals, internal tooling and APIs that hold up under real traffic and real auditors.
We build the web software a business actually runs on — the booking engine, the claims portal, the back office nobody sees but everybody depends on. That means auth that survives a penetration test, data models that don't need rewriting at year two, and a deployment story your team can operate without us in the room.
What you get
- Architecture and threat model documented before the first sprint
- Design system and component library, not disposable screens
- REST or GraphQL APIs with versioning and OpenAPI contracts
- SSO, RBAC and audit logging wired in from the start
- Infrastructure as code, blue-green deploys and rollback that has been rehearsed
- Performance budgets enforced in CI — Core Web Vitals, not vibes
Typical stack
iOS & Android
Native and cross-platform apps, shipped through review, monitored after launch.
Native where the platform earns it, cross-platform where a shared codebase saves you money — and a straight recommendation about which one your product needs. We handle the whole path: prototype, build, signing, store submission, phased rollout, and the crash dashboard you'll actually look at on Monday morning.
What you get
- Platform recommendation backed by your actual requirements and budget
- Offline-first data sync, background processing and push notifications
- Biometric auth, secure storage and certificate pinning
- Accessibility to WCAG 2.2 AA, including VoiceOver and TalkBack passes
- App Store and Play Store submission, review responses and phased release
- Crash and ANR monitoring, plus release-over-release stability reporting
Typical stack
Desktop applications
Windows and macOS software for the work that a browser tab was never going to handle.
Some jobs still belong on the desktop: CAD-adjacent tooling, trading and control-room screens, offline field software, anything talking to local hardware or moving gigabytes around a workstation. We build those properly — native where the OS integration matters, Electron where an existing web codebase can carry its weight — and we ship them with installers and auto-update that your IT team can actually deploy.
What you get
- An honest recommendation on native vs. Electron vs. re-using your web app
- Multi-window, multi-monitor and keyboard-first interfaces built for all-day use
- Local hardware integration — scanners, cameras, serial devices, printers, USB
- Offline-first working with background sync and conflict resolution
- Signed installers (MSI, MSIX, DMG, notarised) and silent enterprise deployment
- Auto-update channels, crash reporting and remote diagnostics from day one
Typical stack
QA & test automation
Regression suites, load tests and release gates that catch things before your customers do.
Quality assurance as an engineering discipline, not a checkbox at the end of the sprint. We build the automated suites, wire them into your pipeline, and give you a release gate that means something — so a green build is genuinely a reason to deploy on a Friday.
What you get
- Test strategy covering unit, integration, contract, end-to-end and exploratory
- Playwright or Appium suites running against every pull request
- Load and soak testing with agreed thresholds and published results
- Accessibility auditing, both automated and manual assistive-tech testing
- Flaky-test triage — a suite nobody trusts is worse than no suite
- Quality dashboards: coverage, escape rate, mean time to detection
Typical stack
Development teams
Embedded senior engineers who join your standups and raise your team's floor.
Sometimes you don't need an agency, you need three more senior engineers by the end of the month. Our people embed in your team, use your board, follow your standards — and leave the codebase and the people better than they found them. We also take on rescue work when a project has gone sideways.
What you get
- Senior and principal engineers embedded in your existing squads
- Technical due diligence and architecture review, delivered as a written report
- Legacy modernisation and strangler-fig migrations with no big-bang cutover
- Rescue engagements: stabilise, document, then plan the way forward
- Mentoring, code review standards and internal engineering guilds
- Fractional CTO and hands-on technical leadership
Typical stack
Engagement models
Three ways to buy
Delivery squad
A cross-functional team — engineers, QA, design — working in two-week sprints against a shared backlog until the thing is live.
- Monthly rolling contract
- Demo every fortnight
- Full repo access from day one
Embedded engineers
Senior people who join your standups, your board and your codebase. Your process, your standards — our experience.
- Day rate, monthly notice
- Minimum three-month term
- Knowledge transfer built in
Questions
The things everybody asks
Who actually writes the code?
The people you meet in the pitch. We don't run a bench of juniors behind a senior front — our average engineer has twelve years of commercial experience, and you'll know all of them by name within a fortnight.
Do we own the code?
Yes, entirely, from the first commit. It lives in your repository under your organisation. There are no licences to buy back and no proprietary framework holding your product hostage.
Can you work with our existing team?
That's most of what we do. We'll follow your branching model, your definition of done and your ceremonies. If we think something in your process is hurting you, we'll say so once, clearly, and then get on with it your way.
What happens when the project ends?
Handover is part of the plan, not an afterthought: documentation, runbooks, architecture decision records and paired sessions with your engineers. After that you can take a support retainer or take it in house — we've built it so that either is genuinely possible.
Not sure which of these you need?
That's what the first call is for. Thirty minutes with an engineer and you'll know.