Open Source Architect

Your engineers lose hours every week waiting for things. I take that waiting away.

Open Source Architect building light, sustainable developer infrastructure and local-first CI/CD automation.

I maintain three open-source tools: a local gate that runs your CI before you push, a dependency-free process that stands in for third-party payment and identity APIs, and an air-gapped automation engine that runs enterprise workflows without a network. All three publish their measurements, and all three publish the claims they do not make.

Case studies, writing and public evidence

Why

The ideas behind the work

Anyone can show you a list of tools. This is the reasoning behind them, and the evidence that I act on it rather than just agreeing with it.

All five
  • Waiting is the most expensive thing in software.

    A four-minute wait per change, twenty changes a day, twenty developers, is over 1,600 hours a year. It is a salary-sized cost that nobody writes down, because it appears as a progress bar rather than an invoice — and sometimes, as an email about a bill.

  • Untestable code is unowned code.

    The riskiest code in a payments or identity product is usually the code with the least testing, because it needs a live account with a third party to run at all. That is not a discipline problem. It is a dependency problem.

  • A number without a method is a rumour.

    Half the tooling industry publishes a benchmark with no way to reproduce it. A benchmark nobody can re-run is a claim with formatting — and it is the only kind of claim that gets checked.

  • The heaviest thing should not run the most.

    A mock engine that idles at eight percent of a core, on every laptop, is a quarter of a gigabyte and twenty seconds of somebody's day — multiplied by everybody. Weight is a cost that only shows up at scale, which is exactly when it is too late to fix.

  • A failure should explain itself.

    A failure that says "test 14 failed" costs twenty minutes and sends you to the wrong place. A failure that says "the runner never started, and here is why" costs ten seconds and points at the right one. The difference is design, not luck.

How this site is organised

Products, writing, and evidence

Three ways in, depending on what you are here to judge.

Three tools, all open source

My Products

CI Kit for a local CI gate that runs the same scripts your workflow runs. api-mock-services for zero-dependency, one-process stand-ins for third-party APIs. An air-gapped automation engine for enterprise workflow execution.

Deep case studies with measured outcomes

Case studies

Three problems, measured end to end

Not a feature list. The failure mode, the intervention, the before-and-after numbers, and what I would do differently.

Case study 02api-mock-services

Four containers, 250 MB, and a proxy that never settled.

How one dependency-free Node process replaced four mock containers — and turned the footprint into a build gate instead of a paragraph

The mock environment was a docker compose file with four services. It was slow to start, it idled at nearly 8% CPU, and one of its containers existed to translate OpenAPI specs — and never finished doing it.

Before 250 MB across four containers, idling at 7.9% of a core
After 50 MB in one dependency-free process, with no idle CPU

Case study 03Automation Gateway

The controller was the problem, not the automation.

An air-gapped Windows Service that runs enterprise workflows from JSON blueprints — and records every attempt, including the ones it had to retry

A platform that can only be extended by editing the thing that runs it will eventually be edited in a hurry, by someone who is not the person who designed it.

Before In controller code changing a workflow needed a code change and a deployment
After A JSON blueprint changing it needs a file review
Read the Automation Gateway case study
  • PowerShell 7
  • Windows Service
  • SQLite

Positioning

I build the unglamorous layer of developer infrastructure: the tools that decide whether a team waits forty seconds or forty minutes for a green build, and the services that keep an enterprise running when the network does not. My work is open source, benchmarked in public, and written up in full — including the measurements I threw away and the claims I do not make. Infrastructure claims are worth exactly what the evidence behind them is worth, so the evidence ships with the tool.

  • Every product I ship is published as open source, with the harness that produced its measurements included, so the claims are reproducible — and with a documented section on what is not claimed.
  • Case studies lead with the failure mode and the before/after numbers, not the feature list. Where a number is unflattering, it stays.
  • The same discipline applies to the systems I build for enterprises: data-driven configuration, explicit audit trails, and a safe path out when a component is unreachable.

LinkedIn headline

Creator of CI Kit, api-mock-services & the Automation Gateway | Specializing in Developer Experience (DX), Local-First Infrastructure, and Air-Gapped Platform Engineering.

Currently

Open to platform engineering and developer infrastructure work

Remote-first. Comfortable working with teams across UK and West Africa time zones.

Specialisms

What I actually work on

Four areas, chosen because I have shipped in them rather than because they sound impressive.

Developer Experience (DX)

Removing the wall between an edit and the signal that says whether the edit was right. Most of it is determinism: the same script has to run on the laptop and on the runner, so there is one copy of the setup rather than two implementations that drift.

Local-First & Air-Gapped Systems

Systems that keep working when the network does not. Mocks that answer a payment API without a key, a local model that classifies intent without a cloud gateway, and an audit trail that stays queryable on the host it was written on.

Platform & Service Engineering

Windows services, runspace pools, transactional persistence, plug-in extension points, RBAC and break-glass recovery. The unglamorous layer that decides whether a platform is operable by one person or by a rota.

Green Container Tooling

Tooling that is light by default: small memory footprints, zero idle CPU, and a deliberate bias toward doing less work on the developer's machine rather than more work on someone's metered runner. The footprint is enforced as a build gate, not asserted in a README.

Tooling I work in daily

Languages
  • Shell
  • PowerShell
  • JavaScript / Node.js
  • TypeScript
  • Python
  • Go
CI / CD
  • GitHub Actions
  • act
  • Docker
  • gitleaks
  • Renovate
Platform
  • Windows Service
  • PowerShell 7
  • SQLite
  • Pester
  • DPAPI
  • Runspace Pools
Developer tooling
  • Make
  • Git hooks
  • OpenAPI
  • Prism
  • Tilt
Domains
  • Payments
  • Identity / KYC
  • Enterprise automation
  • Air-gapped infrastructure
  • Observability

Build in public

Recent writing

Long-form technical essays, cross-posted to Substack and Dev.to. The full archive is on the blog.

The Silent Bill: How a Billing Decision Looked Like 28 Failed Builds

For a week the largest repository in the workspace was red. Twenty-eight runs out of the last thirty had failed. Not one of them had failed on code — and the only clue was that they all failed in six seconds.

  • CI/CD
  • Developer Experience
  • Observability
  • Tooling

Deterministic Toolchains Don't Need a Backend

You do not need a build cache service, a remote execution farm, or a container registry to get a reproducible gate. You need one copy of the setup, and both callers to use it.

  • Reproducibility
  • CI/CD
  • Tooling
  • Shell

Open Source Impact

A pre-packaged evidence base for anyone assessing my work.

Consolidated metrics, community growth, external recognition, public writing and an activity log — all in one printable page, and all linked to primary sources.

  • 2Open-source tools published
  • 1Published measurement documents
  • 100 MBFootprint enforced as a build gate
  • 18Third-party providers mocked

Contact

Email is the fastest route. I respond to technical and collaboration enquiries within two working days.