Web & Software Development
Production web applications and custom software built to hold up under real traffic, real data and real teams.
- Median Lighthouse performance
- 98Median Lighthouse performance
- Faster time to first release
- 2.4xFaster time to first release
- Test coverage at handover
- 85%+Test coverage at handover
How we approach this
We design and ship web platforms end to end — from the data model to the deployment pipeline. Whether you need a customer portal, an internal operations tool or a public product, we build it on a stack your team can own after launch, with the tests, documentation and observability that make that possible.
We start with the data model, not the screens
Most web applications that become painful to change were painful from the first schema. A data model that mirrors how the business actually works absorbs new requirements quietly; one that mirrors the first set of screens has to be renegotiated every time the product grows.
So the first week is spent on entities and relationships — what a customer is, what an order is, what happens when one is cancelled halfway through. We write that down and walk you through it before a single interface is designed. It is the cheapest hour of the project and the one that saves the most later.
Boring technology, chosen on purpose
We build on Next.js, TypeScript, Laravel, Node and PostgreSQL — not because they are fashionable but because they have long support windows, deep documentation and a large hiring pool. When you need to bring the work in-house or hire a second agency, you will not be looking for specialists in something we invented.
Where a project genuinely needs something less common we will say so and explain the trade-off, including what it will cost you in hiring terms three years out.
Performance is a build-time decision
Speed is not something you add at the end. Server-side rendering, sensible caching layers, indexed queries and images processed at build time are architectural choices that cost nothing to make early and a rewrite to retrofit.
Every platform we ship is measured against Core Web Vitals on real devices before launch, not just in a lab, and the numbers go in the handover document alongside the queries that produce them.
Built so you can take it over
The measure of a good build is that you stop needing us. Every project ships with a test suite that runs in CI, a README that gets a new engineer running locally in under an hour, architectural decision records explaining why things are the way they are, and a recorded walkthrough of the system.
We also run a handover session with your engineers where they drive and we answer questions. Teams that have done this are typically shipping their own features within a week.
What you get
- Technical discovery and architecture blueprint
- Custom web application build
- API design, integrations and third-party services
- Database design, migration and performance tuning
- Automated testing and CI/CD pipelines
- Documentation and engineering handover
Is this the right service for you?
We would rather tell you no early than take on work we would do badly. Here is where this service earns its keep, and where it doesn't.
A good fit if
- You have a workflow that spreadsheets or an off-the-shelf tool has outgrown
- You need an application several teams depend on daily
- You have an existing codebase that needs auditing, rescuing or extending
- You want to bring development in-house eventually
Probably not if
- A brochure site with no application logic — you will overpay for us
- Projects needing a specific enterprise stack we do not work in
- Work where the requirements cannot be pinned down enough to scope
How a web & software project runs
- 01
Model the domain
Interviews with the people who do the work today, then a written data model and architecture proposal. You approve it before anything is built.
- 02
Walking skeleton
In sprint one we ship the thinnest end-to-end slice — one real workflow, deployed, authenticated, in your cloud account. Everything after is filling it in.
- 03
Sprint and review
Two-week sprints, each ending with a deployed build on a staging URL and a session where you use it. Scope closes at the halfway point.
- 04
Harden and hand over
Load testing, error budgets, monitoring and alerting, then documentation and a live walkthrough with your engineers driving.
Ways to work with us
Starting prices, not quotes. You get a fixed number in writing after discovery — these are here so you can tell early whether we're in your range.
Technical audit
We review an existing codebase, infrastructure and delivery process, then give you a written report: what is solid, what is a liability, and what it costs to fix each item.
- From
- $6,000
- Typical timeline
- 2 weeks
- Best for
- Inherited or stalled codebases
MVP build
Discovery, design and a first production release of a focused application, scoped to the single workflow that carries the value.
- From
- $45,000
- Typical timeline
- 10–14 weeks
- Best for
- First version of a new product
Platform build
A multi-role application with integrations, reporting and an admin surface, delivered in two-week sprints with a deployable build at the end of each.
- From
- $110,000
- Typical timeline
- 4–6 months
- Best for
- Systems several teams depend on
Web & Software questions
The ones that come up on nearly every call for this service.
- Can you take over a codebase someone else started?
- Yes, and it is a large share of what we do. We start with a two-week technical audit so we can tell you what we found before quoting the work — occasionally that report concludes the honest answer is a rewrite, and we would rather say so upfront than discover it in month three.
- Do you write tests, and does that cost extra?
- Tests are included, not an upsell. We target around 85% coverage on business logic at handover, with end-to-end tests on the critical paths. Untested code is slower to change, which makes it more expensive for you later, so treating tests as optional would be a false saving.
- Whose cloud account does it run in?
- Yours, wherever possible. We work inside your AWS, GCP or Vercel account and your GitHub organisation from day one. You keep the billing relationship, the audit trail and the ability to revoke our access at any point.
- What if requirements change mid-project?
- Small changes get absorbed. Anything that alters the agreed scope gets priced as a change before we build it, so the number never moves without your sign-off. We close scope at the halfway point of a build — after that, new ideas go on the list for the next phase rather than destabilising the release.
- Can you work alongside our in-house engineers?
- Often, and it usually produces the best handover. We work in your repositories, follow your review process and pair with your team on the parts they will own. It slows the first sprint slightly and saves months afterwards.
Need web & software help?
Send us the brief, the half-written brief, or just the problem. We'll come back with what we'd do and what it costs.