Skip to content

Web Applications

Web applications built to a performance and accessibility budget from the first commit, not audited into shape at the end.

What this is

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.

When you need it

If more than one of these is true, this is usually the right place to start.

  • Your application feels slow on mid-range phones and on connections outside the office, and nobody can say which change made it that way.
  • An accessibility requirement has appeared in a tender or a procurement checklist and you do not know whether the product would pass.
  • Releases need a maintenance window and a manual rollback plan, so changes queue up instead of shipping.
  • The same business rule exists in three places because the browser, the API and a background job each grew their own copy.

What the scope covers

  • Frontend architecture: rendering strategy, routing, state boundaries and the component contract the team will build against.
  • Accessibility to WCAG 2.2 AA built into components and verified in the pipeline, not left to a final audit.
  • A performance budget expressed as numbers in CI, so a regression fails a build rather than reaching production.
  • API layer and data model design, including caching, pagination and the error contract the client depends on.
  • CI/CD, environment separation and observability, so a deploy is a routine event with a known rollback path.

What you receive

DeliverableWhat it contains
Architecture and ADRsA 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 libraryAccessible, tested UI components with documented props, focus behaviour and keyboard handling, so every screen inherits the same interaction rules.
Application and API codeThe running application, its API layer and data access, delivered into your repository together with the test suite that guards it.
Pipeline and runbookCI/CD configuration, environment definitions, budget and accessibility gates, and a written runbook for deploy, rollback and incident triage.

Reference architecture

A reference, not a template. Your estate decides which parts apply and in what order they arrive.

Web applications reference architecture: experience, platform and delivery layersExperience: Responsive UI, Accessibility, Performance Budget. Platform: Application Runtime, API Layer, Data Store. Delivery: CI / CD, Environments, ObservabilityExperienceResponsive UIAccessibilityPerformance BudgetPlatformApplication RuntimeAPI LayerData StoreDeliveryCI / CDEnvironmentsObservability
Web applications reference architecture: experience, platform and delivery layers

How success is measured

Targets are agreed with you before the work starts, and reported against for its duration.

  • Core Web Vitals — LCP, INP and CLS — measured from field data on your real traffic, not only from lab runs.
  • Accessibility violations by severity, counted per build from automated checks plus a recorded manual keyboard and screen-reader pass.
  • Deployment frequency, change failure rate and time to restore, read from your own pipeline and incident records.

Questions we are asked

  • Do you work with our existing codebase, or will you insist on a rewrite?

    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.

  • Which framework will you use?

    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.

  • How much does accessibility add to the cost?

    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.

  • Can you hit a performance budget on a content-heavy page?

    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.

  • Who owns the code and the pipeline when the engagement ends?

    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.

  • Do you support the application after launch?

    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.

Continue reading

  • Mobile Applications

    iOS and Android applications where offline behaviour, sync and conflict rules, a backend for frontend and the store release pipeline are designed up front.

  • Enterprise Software

    Custom enterprise systems designed around the data model and the integration surface, with role-based access, an audit trail and a reconciled data migration.

Start with an assessment

The fastest way to a useful answer is a short, scoped look at what you already have.