Software factory

We build the software.
We keep the environments.

Product teams, delivery pipelines and hardened environments, shipped as one unit — from the first architecture call to the alert that wakes someone at 03:00.

What we build

Four things, done properly

A factory is not a body shop. You get a team that owns the outcome, the pipeline it ships through, and the environments it runs in.

Product engineering

Web, mobile and API surfaces built to be handed over rather than hoarded — documented, tested, and readable by whoever comes next.

Platform & delivery

CI/CD, infrastructure as code, and observability wired in from day one. Deploys that are boring on purpose, because boring is what lets you ship on a Friday.

Environment custody

Secrets, configuration and parity across development, staging and production. The part every team improvises — we own it, name it, and rotate it.

Reliability

Alerts that mean something, runbooks that match reality, and a person on the other end of the page instead of a dashboard nobody opens.

The line

Five stations, in this order

Every engagement runs the same sequence. The order is the point: skipping a station is how projects acquire the problems we get called in to fix.

01

Discover

One week to map the domain, the constraints and the riskiest assumption in the plan. You get the map whether or not you continue with us.

02

Architect

Boundaries, data model, environments and the deployment story — agreed and written down before anyone writes production code.

03

Build

Small increments behind feature flags, reviewed continuously, demoable every week. No six-week silence ending in a surprise.

04

Harden

Load, failure and secret-handling tested before launch instead of after the incident. Rollback rehearsed, not theorised.

05

Operate

Dashboards, alerting and on-call — with the keys handed to your team whenever you want them, and documentation good enough to make that painless.

Guarded by default

Your environment is your blast radius

The name is not decoration. Configuration and secrets are where most incidents actually begin, so they are treated as a deliverable — not as something pasted into a chat thread.

production · sealed
01

Least privilege, actually enforced

Every service gets its own credential with the narrowest scope that works. Shared logins are treated as an incident, not a convenience.

02

Parity across environments

Staging matches production in shape, not just in name — same topology, same migrations, different data. "It worked locally" stops being an explanation.

03

Rotation on a schedule

Keys have an expiry and an owner from the day they are created, so rotating one is a routine task rather than an outage waiting for a trigger.

04

Recovery that has been tested

Backups are restored on a schedule. An untested backup is a belief, and beliefs do not survive contact with a failed disk.

Engagements

Three ways in

Fixed scope

Build a product

A defined outcome with a defined budget, delivered by a team that stays with it from discovery to launch.

  • Discovery week first
  • Weekly demos
  • Handover documentation included

Monthly

Embedded squad

Engineers who join your rituals and your repository, with our delivery practices coming along with them.

  • Two to five engineers
  • Your board, your standup
  • Month-to-month

Fixed price

Platform rescue

For a system that ships slowly or breaks often: an audit that names the causes, then the work to remove them.

  • Two-week audit
  • Prioritised findings
  • Fixes quoted separately

Next step

Tell us what needs building

Send a paragraph about the problem. You will get a real reply from an engineer, not a sequence of discovery calls.