Software & Platforms
The full domain, and the other capabilities within it.
Web applications built to a performance and accessibility budget from the first commit, not audited into shape at the end.
A web application is software your users reach through a browser, where the interface, the API behind it and the data store are all part of one delivery problem. We design and build these end to end: the rendered experience, the runtime that serves it, the API layer it talks to, and the pipeline that ships changes into production.
The failure mode we see most often is a project where accessibility and performance were scheduled as a hardening phase after feature-complete. By then the component library, the routing model and the data-fetching pattern have all been chosen against those goals, and the fix is a rewrite of the layers that touch every screen.
If more than one of these is true, this is usually the right place to start.
| Deliverable | What it contains |
|---|---|
| Architecture and ADRs | A written record of the rendering, state and data-access decisions, each with the trade-off it accepts, so the next engineer inherits reasoning rather than guesswork. |
| Component library | Accessible, tested UI components with documented props, focus behaviour and keyboard handling, so every screen inherits the same interaction rules. |
| Application and API code | The running application, its API layer and data access, delivered into your repository together with the test suite that guards it. |
| Pipeline and runbook | CI/CD configuration, environment definitions, budget and accessibility gates, and a written runbook for deploy, rollback and incident triage. |
A reference, not a template. Your estate decides which parts apply and in what order they arrive.
Targets are agreed with you before the work starts, and reported against for its duration.
We start by reading what you have and mapping the parts that are load-bearing. Most engagements are incremental: a new rendering or routing approach applied route by route, with old and new paths running side by side. A rewrite is a recommendation of last resort, and if we make it we will show you the specific constraints that forced it.
We work mainly with React and Next.js, and with plain TypeScript and web platform APIs where a framework would add more than it removes. If your team already runs Angular or Vue and maintains it well, we build in that stack rather than introducing a second one. The framework matters less than the boundaries between rendering, state and data access.
Built in from the start, it is largely absorbed by work you were doing anyway — choosing accessible primitives and correct semantics instead of inaccessible ones, at similar effort. Retrofitting is where the cost appears, because it reaches into markup, focus management and sometimes the design itself. That is the argument for deciding it at the beginning.
Usually, but it constrains choices: what renders on the server, how many third-party scripts are allowed, how images and fonts are loaded. The budget is a design input, not an outcome. We agree the numbers before the build and enforce them in CI, and when a feature cannot fit inside them we say so rather than quietly raising the limit.
You do. Work lands in your repository, under your accounts and your cloud tenancy, from the first week rather than at handover. Handover itself is a scheduled activity: documentation, a walkthrough of the pipeline, and a period where your engineers lead and we review.
Yes, through our managed services and support models, with an agreed scope for monitoring, dependency updates and incident response. It is a separate agreement from the build, so you can also choose to run it yourself. Either way we design the observability and runbooks assuming someone other than the original authors will be on call.
The full domain, and the other capabilities within it.
iOS and Android applications where offline behaviour, sync and conflict rules, a backend for frontend and the store release pipeline are designed up front.
Custom enterprise systems designed around the data model and the integration surface, with role-based access, an audit trail and a reconciled data migration.
The fastest way to a useful answer is a short, scoped look at what you already have.