<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Omeiza Okuta — Build in Public</title>
    <link>https://omeiza-workspace.github.io/blog/</link>
    <atom:link href="https://omeiza-workspace.github.io/feed.xml" rel="self" type="application/rss+xml" />
    <description>Omeiza Okuta is an Open Source Architect building light, sustainable developer infrastructure and local-first CI/CD automation. Creator of CI Kit and api-mock-services.</description>
    <language>en-gb</language>
    <lastBuildDate>Thu, 22 Oct 2026 16:00:05 GMT</lastBuildDate>
    <managingEditor>okuta.omeiza@gmail.com</managingEditor>
    <item>
      <title>The Silent Bill: How a Billing Decision Looked Like 28 Failed Builds</title>
      <link>https://omeiza-workspace.github.io/blog/the-silent-bill-remote-ci-cd-drift/</link>
      <guid isPermaLink="true">https://omeiza-workspace.github.io/blog/the-silent-bill-remote-ci-cd-drift/</guid>
      <pubDate>Fri, 18 Sep 2026 00:00:00 GMT</pubDate>
      <description>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.</description>
      <content:encoded><![CDATA[There is a failure mode in CI that is worse than a red build, and it is invisible by construction.

A red build at least tells you something. It says: this change, on this commit, in this environment, did not work. It is annoying, it costs you minutes, and it is honest.

The failure mode I am describing tells you the exact same thing, and it is a lie.

## The week nothing ran

On 21 October 2026, the largest repository in the workspace had **28 failing runs out of the last 30**.

Every one of them failed in about six seconds.

Six seconds is the tell. A test suite takes as long as the test suite takes. A compile error takes as long as the compile takes. Six seconds is how long it takes a runner to allocate, start a job, decide it will not start it, and give up.

The annotation said exactly what had happened:

> The job was not started because recent account payments have failed or your spending limit needs to be increased. Please check the 'Billing & plans' section in your settings

GitHub had refused to start the jobs. The same annotation was on the failures in a second repository.

But at the level of the pull request, a red build is a red build. The developer assumes their change broke something. They fix a problem that does not exist, or they push again and wait. What had actually happened was that **nothing was verified at all**, and the reason was one line of text in a log nobody reads.

The repository was not failing. It was unverified. And for a week, nobody could tell the difference.

## The bill

The cost of that week was not the compute. No runner minutes were billed, because no runner started. The cost was the *guarantee*.

| | Remote CI | Local gate |
|---|---|---|
| Feedback on a push that breaks the build | 4–12 min, billed | ~100 s, free |
| Feedback when the runner never starts | 6 s, and it says why — if you read it | ~100 s, and it says why |
| Feedback when the runner never starts and you are not reading the log | never | ~100 s |

That last row is the one I keep returning to. The gap is not between a fast answer and a slow answer. It is between an answer and no answer at all, and the difference between those two states is whether anyone happens to be reading a log.

## The bill nobody sees

The instinct of most engineering leaders, when a bill gets uncomfortable, is to look at the number next to it: the cloud invoice. Runner minutes. Storage. Egress. That number is real, it is attributable, and reducing it produces a clean chart. It is also, in my experience, the smallest and least interesting part of the problem.

The expensive part is the waiting. Not the minutes billed — the minutes *spent*.

Consider the mechanics of a slow pipeline. A developer makes a change, pushes it, and then waits. If the wait is short, the change stays in their head and the next change is a refinement of the same thought. If the wait is long, the developer's mind wanders, opens a ticket, answers a message, or starts a completely different piece of work. When the pipeline finally reports back, the context required to interpret it has partially decayed.

That reconstruction cost is invisible. But it is paid on every commit, and it is the reason a two-minute pipeline and a nine-minute pipeline are not merely different in comfort but different in output.

## What a local gate is actually for

I want to be careful here, because the marketing for this category is relentless and most of it is wrong.

**A local gate is not faster than a CI runner.** I measured it. On identical work — `npm ci`, two type checks, vitest, the build — the local gate took 99 seconds on a 2022 Intel laptop against 43–48 seconds on a GitHub runner. A modern runner has more cores and faster storage, and for work that is mostly `npm ci` and TypeScript, it wins. The local gate on that machine was roughly twice the wall clock of the remote job.

The first attempt at that measurement was discarded: the machine had a load average of 212 from an unrelated build, and the same gate took 194 seconds under that load against 105 without it. Both numbers are published, because the first one is what a measurement looks like when nobody checks the load.

So the local gate is not a speed optimisation. It is a **guarantee of feedback**, and it buys that in three ways:

1. **It always runs.** The remote one did not, for a week, and nobody noticed what that meant.
2. **It runs before the push.** A broken commit never reaches the branch.
3. **It is the same script**, so its verdict and the workflow's verdict agree by construction rather than by luck.

If your CI is fast, healthy and free, a local gate is a convenience. If your CI bills by the minute, or is red for reasons unrelated to your code, it is the only signal you have.

## Drift is real, and it is not what bit us

I should say this plainly, because the category I work in is sold on drift, and drift is a real problem. A runner image gets a patch upgrade. An action is referenced by tag and the tag moves. A cache restores a different lockfile resolution than the commit was written against. Each of those is individually invisible and collectively fatal: the build is not wrong in an obvious way, it is wrong in a *plausible* way, which is the worst way to be wrong. The failure points at your code, so your code gets debugged. Your code is fine.

But drift was not what happened in my workspace. Drift is the more interesting failure and it announces itself over weeks. What happened was one line of text about billing, and it took a week to notice.

The tell for drift is different. A genuinely flaky test is not fixed by trying again. **A job that goes green on the second attempt is telling you the environment changed between the two attempts.** If you are not measuring that rate, you are not measuring drift.

## What the gate found that CI could not

This is the part that made the case for the tool, and it is not about speed at all.

Running the local gate against repositories whose CI was in the state above found three real defects, in under four minutes, on a laptop, with no runner minutes spent:

- **A stale secret-scan allowlist.** `.gitleaksignore` named `LOCAL_DEVELOPMENT_GUIDE.md`, but the file had moved to `docs/product/LOCAL_DEVELOPMENT_GUIDE.md`. The fingerprint never matched, so a tracked documentation file — a `curl` sample containing the literal string `YOUR_TOKEN` — was failing the secret scan. The file is tracked, so the CI scan was failing on it too. The CI had been red for the same reason the jobs were not starting, and nobody could tell the two apart.
- **Ninety-three dependency advisories.** 53 high, 8 critical. The same command CI runs.
- **Build artefacts tripping a working-tree scan.** Playwright traces under `test-results/` contain a token, and a working-tree secret scan reads them.

The first one is the story. There were two independent causes of red in that repository, and they were indistinguishable from the pull request view. One of them was a documentation file that had moved.

## The fix is dull, and that is the point

The remedy is not a new CI vendor, a build cache service, or a migration to a faster runner. It is a discipline:

1. **One copy of the setup.** The gate scripts live in the repository and both the Makefile and the workflow call them. There is no second implementation to drift.
2. **Make the failure loud.** Classify it. A job that did not start is not a test failure, and it should not look like one.
3. **Move the fast gate local.** The checks that run on every commit should run on the machine in front of the developer, in the same scripts CI uses.
4. **Know whether you are faster or guaranteed.** Measure both, publish both, and do not confuse them.

Step four is the one that requires actual courage, because it is the one where the honest answer is usually less flattering than the pitch.

## What to measure this month

If you take one thing from this: find your job failure rate, and read the annotations on the failures rather than assuming they are test failures. If jobs are failing in seconds, something is failing before the job starts, and your pipeline is not telling you it is red — it is telling you it is *unverified*.

That is the Silent Bill. It does not appear on the invoice, because nothing was billed. It is paid in unverified commits.

The implementation is open source: [CI Kit](https://github.com/omeiza-workspace/ci-kit), with the full measurement — including the number I threw away — in its [evidence document](https://github.com/omeiza-workspace/ci-kit/blob/main/docs/EVIDENCE.md).]]></content:encoded>
      <category>CI/CD</category>
      <category>Developer Experience</category>
      <category>Observability</category>
      <category>Tooling</category>
    </item>
    <item>
      <title>Architecting Local Sandboxes for Interswitch and Paystack Integrations, Completely Offline</title>
      <link>https://omeiza-workspace.github.io/blog/architecting-local-sandboxes-offline/</link>
      <guid isPermaLink="true">https://omeiza-workspace.github.io/blog/architecting-local-sandboxes-offline/</guid>
      <pubDate>Thu, 27 Aug 2026 00:00:00 GMT</pubDate>
      <description>Four containers, 250 MB, 7.9% idle CPU, and 20 seconds before the first request was answered. How one dependency-free Node process replaced the whole arrangement — and why the footprint became a build gate rather than a paragraph.</description>
      <content:encoded><![CDATA[The first rule of a sandbox is that it must be more available than the thing it imitates. The payment API has a sandbox, and it is more available than our own production build, which is a sentence nobody should be able to write about a payment API.

This is the situation across much of African FinTech: a payment product where the integration surface is a set of third-party gateways — Interswitch, Paystack, Flutterwave, and a long tail of regional acquirers — each with its own authentication scheme, its own webhook envelope, and its own definition of what a successful transaction looks like. And each with a sandbox that requires network access, a credential request, and often a conversation with the provider's support desk.

The result is a testing regime that I can only describe as inverted: the code most likely to lose money is the code least likely to be exercised automatically.

## The inversion

Here is what a normal engineering org looks like. The payment path has unit tests, integration tests, a mocked gateway, and a staging environment that mirrors production. The team ships with confidence.

Here is what an org with a hard external dependency looks like. The payment path is excluded from CI because the CI environment has no credentials. A staging environment exists, but it is a shared box that people log into to poke at manually, which means it is a bottleneck, and bottlenecks get skipped. New engineers take three weeks to write their first payment test, because getting to that point requires a person who knows which internal wiki page explains the sandbox credential rotation.

The testing of the riskiest code is manual, senior-only, and late. I have seen this pattern in three companies now, and the reason it survives is that the risk is invisible in every dashboard. The dashboard shows green builds, because the payment tests are not in the build.

## The arrangement we had

The workspace's answer was a `docker compose` file with four services: the mock service, an OpenAPI proxy that served the provider specs, and two supporting services.

Measured on one machine with every mock running:

| | the four containers |
|---|---|
| processes | 4 |
| memory | 250 MB |
| of which the OpenAPI proxy | 214 MB, and it does not settle |
| idle CPU | 7.9%, almost all of it the proxy |
| time to first request answered | 20 s and rising |
| things to start, stop and clean up | 4 |

Two things in that table deserve attention. First, **214 MB of the 250 MB was the proxy** — the component whose only job was translating a specification, and which never finished doing it. Second, **7.9% idle CPU**. The arrangement was not idle. It was translating specs that were already translated, forever, at a rate that made the laptop warm.

And the arithmetic was brutal. On a developer laptop, where memory is the scarcest resource, a test setup that permanently occupies a quarter of a gigabyte and burns eight percent of a core is not a tool that gets used often. It is a tool people queue for, postpone, and eventually bypass — which puts the test back to manual, and the manual version back to one senior person who knows how to run it.

## The requirement that changes the design

Most mocking tools are built on the assumption that a network is available. You spin up a container, it reaches out, you point your service at it. This is fine for mocking an internal service. It is close to useless for the case we care about, because:

- A developer on a poor connection, or on a train, or behind a corporate proxy cannot start the environment.
- CI needs the environment to be reproducible, which means the mock needs to be reproducible, which a container that pulls from a registry does not guarantee.
- A developer in a different timezone cannot debug against a shared environment, because the shared environment is a single point of contention for people who are asleep.

The requirement that changes everything is this: **the sandbox must work with the network unplugged.** Not degrade. Work. Fully. Including the parts that reach out — webhooks, callbacks, settlement notifications.

That single constraint pushes you towards a native runtime with no external dependencies, and towards modelling behaviour rather than serving static fixtures.

## Model behaviour, not endpoints

The most common way to build a mock is a set of URL handlers. You write `POST /api/charge` and return a canned success. It is fast to build and it teaches you almost nothing.

The failure of endpoint-shaped mocks is that they model the *interface* of a provider and not its *behaviour*. A real gateway's behaviour is mostly about what happens when things go wrong:

- It declines with a taxonomy of decline codes, not a boolean.
- It times out on a particular operation, and the timeout means the transaction may still have succeeded.
- It delivers webhooks more than once, and out of order, and sometimes days later.
- It settles on a different day than the transaction, sometimes partially.
- It rejects a signature that is correct but uses an old timestamp.

None of that is in the happy-path fixture. All of it is what breaks production. So each provider is modelled as a unit with a behaviour contract — authentication, validation, decline taxonomy, webhook emission, retry policy, settlement timing — and the HTTP surface is generated from the model.

## The rules, and why they are rules

The rewrite did not add features. It removed everything removable, and then made the result a rule rather than a preference. The rules are published at the top of the README, because a contributor who breaks one of them breaks the promise in the first line of the file:

**No dependencies.** Not 'few' — none. The engine runs on Node's own HTTP server. A dependency is a package to install, audit and keep out of the advisories.

**No runtime that costs memory to start.** A JVM, a compiled Go binary or a Python environment all add to the footprint before a single request is served. Node is already on the machine, because the project under test runs on it.

**One process for every mock.** Nine mocks in one process cost 50 MB. Nine containers cost nine runtimes.

**In the test, not beside it.** A test that needs a mock starts it in the test process, with `startMock()`. Nothing listens on a port, no container starts, and the mock stops when the test ends. This is the cheapest way to mock anything, and it is why the engine is a library first and a service second.

**Idle means idle.** A mock answers a request and then stops computing. Polling, watching and retrying are how a mock turns into a battery drain.

That last rule is the one most engines get wrong, and it is the reason this one measures 0.0% idle CPU while the stack it replaces sits at 7.9%.

## The result

| | the engine | four containers |
|---|---|---|
| processes | 1 | 4 |
| memory | 50 MB | 250 MB |
| idle CPU | 0.0% | 7.9%, almost all of it the proxy |
| time to first request answered | 1.4 s | 20 s and rising |
| things to start, stop and clean up | 1 | 4 |

One process. 50 MB. Nothing at rest. And the first request answered in 1.4 seconds instead of twenty.

The measurement was taken by sampling with `ps` for resident size and two `ps -o time=` samples five seconds apart for CPU. The containers were sampled with `docker stats --no-stream`, once immediately and once after they had settled.

## The promise is a build gate

Here is the part I would point at if I could only keep one thing.

The footprint is now a build gate. The footprint test fails the build if the engine exceeds 100 MB, 5 seconds of startup, or 1% idle CPU. A promise nobody checks erodes; this one is checked on every build.

That is why the numbers on this page can be stated without hedging. They are not a claim in a README that will quietly stop being true — they are a constraint that breaks the build when it stops being true. The gap between a number in a README and a number in a test is the gap between a claim and an enforced property.

## The providers

Eighteen, and they are the ones that actually matter in the markets I work in:

| | |
|---|---|
| Payments | Stripe, Paystack, Interswitch, Flutterwave, Monnify |
| Identity | YouVerify, Smile ID, IdentityPass |
| Messaging | Twilio, Termii, OneSignal, WhatsApp, FCM |
| Everything else | Resend, Xero, Cloudflare, OpenAI, S3 |

Every mock answers `/health`, so a container can be checked without knowing which mock it is. Provider contracts are held as OpenAPI documents, with a download script that keeps them current, so the mock and the published contract cannot quietly diverge.

## What I would do differently

Two things, both learned late.

**Model the state machine before the endpoints.** I built the HTTP surface first and it showed. When settlement semantics forced a refactor, it was invasive. If I were starting again I would write the state machine — authorize, capture, settle, reverse — and derive the endpoints from it.

**Ship the decline taxonomy early.** Every provider's decline codes are public and boring, and they are the vocabulary your business logic has to speak. Making that vocabulary available in the first week would have saved us from a quarter of confusion in the integration layer.

## Why this matters beyond payments

The pattern generalises. Any team whose product depends on a third-party API they do not control, cannot test against, or cannot get credentials for, has this problem: the dependency is the reason the code is untested.

The fix is not to mock harder. It is to move the environment onto the developer's machine, make it deterministic, and make the failure paths a first-class part of the model. Then a network outage stops being a reason not to test — and you get your integration suite back.

The implementation is open source: [api-mock-services](https://github.com/omeiza-workspace/api-mock-services). The discipline — pin it, make it loud, keep it local, fail deterministically — is in [CI Kit](https://github.com/omeiza-workspace/ci-kit). Both exist because a team I worked with had a payment path that only one person could test, and we decided that was not acceptable.]]></content:encoded>
      <category>Payments</category>
      <category>Offline</category>
      <category>Node.js</category>
      <category>Testing</category>
      <category>FinTech</category>
    </item>
    <item>
      <title>Deterministic Toolchains Don&#39;t Need a Backend</title>
      <link>https://omeiza-workspace.github.io/blog/deterministic-toolchains-dont-need-a-backend/</link>
      <guid isPermaLink="true">https://omeiza-workspace.github.io/blog/deterministic-toolchains-dont-need-a-backend/</guid>
      <pubDate>Thu, 09 Jul 2026 00:00:00 GMT</pubDate>
      <description>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.</description>
      <content:encoded><![CDATA[There is a category of tooling proposal I have learned to decline on sight: the one whose first slide is an architecture diagram with a service in the middle of it.

A build cache service. A remote execution farm. A resolution proxy. These solve real problems, and every one of them adds a component that can be slow, that can be down, and that introduces a new place for versions to drift.

The question worth asking is not 'can I build this service'. It is 'what is the smallest set of facts that makes the build reproducible, and where do those facts have to live?'

## The facts

For a build to be reproducible, you need to know exactly:

1. Which runtime version executes it.
2. Which dependency resolution it uses.
3. Which artefacts — images, binaries, action SHAs — it consumes.
4. Whether all of the above are identical on the laptop and on the runner.

That is the entire requirement. Four facts. One of them — dependency resolution — is already in a lockfile in most ecosystems. The other three need a small, committed document that says: this runtime, this resolution, these digests.

## The lockfile is the whole product

Once you have a lockfile, the interesting design question becomes: what reads it?

The answer is a resolver — a program that takes the lock and produces a concrete local environment. The resolver has to run in two places, and it has to behave identically in both. That is the entire constraint.

If the resolver is a local script, then:

- The laptop and the runner invoke the same implementation, so they cannot disagree about anything except hardware.
- There is no service to be slow or unavailable.
- The lockfile is a plain, reviewable, diffable text file.
- Adding a teammate is a `git clone` and a cache warm, not an onboarding request.

The remote-execution approach optimises for a different problem — the one where the build is genuinely expensive to run, where a fleet of beefy machines genuinely helps. That is a real case. It is also not the case for the fast checks that run on every commit, and those are the ones setting your feedback latency.

## The version I actually shipped

When I built this for real, the answer turned out to be simpler than a resolver. The repository holds the setup in `scripts/ci/`, and **both** the Makefile and the GitHub Actions workflow call those same scripts. There is one copy of the setup. It cannot disagree with itself.

```
   developer                repository                  runner
      |                        |                           |
      |   make ci              |                           |
      |----------------------->|                           |
      |                        |  scripts/ci/*.sh          |
      |                        |  the setup and the gates  |
      |                        |         |                 |
      |                        |         +---------------->|
      |                        |            the same script|
      |                        |                           |
      |   the same script, so the local run and the runner
      |   cannot disagree about what the code needs         |
```

No resolver. No service. No lockfile format to design. Just: do not write the setup twice.

## The hard part is failure, not success

The subtle requirement is what happens when the environment cannot be honoured. The runner is an image you do not control. The base image has been updated. The action tag moved. The cache restored something unexpected.

A build system that fails with a confusing test error has lost. It has converted a five-second diagnosis into a twenty-minute one, and it will do this several times a week. The failure must be classified:

```
error: toolchain mismatch
  lock:   runtime go1.23.4, digest sha256:9f2c...
  runner: runtime go1.22.9, digest sha256:41ab...

  this job cannot reproduce the tested environment.
  run `make ci` locally to reproduce, or update the lock deliberately.
```

That error is the product. Everything else is plumbing. A fast build that fails for the wrong reason is still a distraction; a slow build that fails for the right reason is a roadmap.

## The part that surprised me

The version of this I did not expect was the inverse of a speed tool. I had assumed the local gate would be faster than the runner, and measured it at 99 seconds against 43–48 seconds on identical work. It was slower, roughly twice the wall clock.

What the local gate actually bought was a *guarantee*. The remote runner had been refusing to start jobs for a week — 28 of the last 30 runs failing, none of them on code — and the local gate had answered the same question every time, on a laptop, for free.

So the honest pitch is not 'faster'. It is 'always available, and it says why'. That is a less impressive sentence than the one I had written, and it is the one that survived contact with a measurement.

## The cache is not the point

Every proposal in this space eventually adds a cache, because a cold build is slow and a cache makes it faster. But a cache is a second copy of the truth, which means it is a second place for the truth to be wrong.

The cache should be keyed by the content of the lockfile, not by the commit SHA. If the lock changes, the key changes, and a stale entry is unreachable by construction rather than by a policy that someone has to remember. Content addressing is not an optimisation here; it is how you make staleness structurally impossible.

## What this looks like in practice

The end state is boring in the best way:

```
$ make ci
running the gates
✓ lint
✓ type check
✓ tests (412 passed)
✓ secret scan
all gates passed in 99s
```

Ninety-nine seconds, on a laptop, offline, with a build that the runner will reproduce exactly because both read the same scripts.

There is no service. There is no cluster. There is one copy of the setup and a rule that if the environment does not match, the build stops and says so.

That is most of the value of the expensive architectures, at essentially none of the cost. Which is, I think, the general shape of infrastructure work: the winning move is usually to make the state explicit and small, not to add a component that holds the state for you.]]></content:encoded>
      <category>Reproducibility</category>
      <category>CI/CD</category>
      <category>Tooling</category>
      <category>Shell</category>
    </item>
    <item>
      <title>The Green Build Myth: Why &#39;Faster&#39; and &#39;Cheaper&#39; Are Usually the Same Decision</title>
      <link>https://omeiza-workspace.github.io/blog/the-green-build-myth/</link>
      <guid isPermaLink="true">https://omeiza-workspace.github.io/blog/the-green-build-myth/</guid>
      <pubDate>Thu, 21 May 2026 00:00:00 GMT</pubDate>
      <description>Lightweight developer tooling is a sustainability decision disguised as a performance decision. The runtime bill and the energy bill turn out to be the same line item.</description>
      <content:encoded><![CDATA[The framing I want to push back on is the one that treats a lightweight developer environment as a purely technical optimisation. Smaller images, faster cold starts, less memory — these are presented as wins on a latency chart, and the carbon consequences are mentioned, if at all, as a footnote.

I think that is backwards, and I think the technical argument gets stronger once you make the environmental one explicit. Because the same decision — do less work, on less hardware, for less time — turns out to be the same decision in both frames.

## The arithmetic nobody does

Consider a typical engineering organisation. Say two hundred engineers, each pushing twenty commits a day, each commit triggering a pipeline of twenty minutes on a metered runner.

That is two hundred times twenty times twenty minutes: roughly thirteen thousand runner hours per day, or around forty thousand per month, of continuously running machines whose entire purpose is to produce a boolean.

Now, a very large share of those jobs are the *same job*. Linting the same repository. Running the same unit tests. Building the same image. The pipeline is a factory that manufactures a green or a red, and it is manufacturing an enormous volume of the exact same green.

Move the fast checks to the developer's machine — checks that are fast, deterministic, and need no shared state — and you can remove the majority of that forty thousand hours. Not by cancelling work, but by doing it where the person who needs the answer already is.

The compute saving is real and it is large. But the carbon consequence is the same forty thousand hours, just not spent in a data centre. The laptop was already on. The developer's laptop is already using its power budget for the work they were doing anyway. You are not moving a marginal cost to a zero cost; you are moving a cost from *new* computation to *already-committed* computation.

## Containers make the trade explicit

This is where the container count stops being a trivia point and starts being the actual decision.

A CI runner that pulls a 900 MB image to run a linter has done roughly two orders of magnitude more I/O than the linter needed. That I/O is not free at the disk, and it is not free in the time it takes before your job can start, and it is not free in the registry bandwidth it consumed. A 90 MB image for the same job is a different system, not a smaller one.

The same arithmetic applies to the developer's machine. I measured the mock service rewrite directly: four containers at 250 MB and 7.9% idle CPU, against one process at 50 MB and 0.0% idle CPU.

Both were running on the same laptop, at the same time, doing the same work. The 1.8 GB and 22 MB figures I used to quote were from a different experiment and are not comparable — which is, in fairness, exactly why published measurements should say which experiment they came from. These ones do.

The laptop version is the one that gets used. The team that ran a mock on a shared server queued for it. The team that ran a 50 MB process on every laptop just ran it. Same features, completely different total footprint, and the total footprint is the thing that determines how much infrastructure you need at all.

## The uncomfortable corollary

If the energy cost of developer tooling tracks the amount of redundant compute, then the industry's default of running everything remotely is the expensive choice, and it is expensive on both axes at once.

This is not a new observation. But it is usually stated in a way that sounds like a sacrifice — 'you have to give up the shared environment to be greener'. That framing is wrong. The local-first path gives you *better* latency, *better* debuggability, *lower* cloud spend and *lower* total energy. There is no trade-off to make. The trade-off was already being made, silently, by not moving the work.

## What I actually do about it

I keep a simple rule for any tooling decision: prefer the option that does not require new computation over the option that requires a smaller amount of new computation.

It shows up concretely:

- **No dependencies.** Every dependency is a package to install, audit and keep out of the advisories. Zero is not asceticism; it is a decision about who audits it.
- **One process instead of four.** Four runtimes cost four times the memory and four times the startup, for the same mocks.
- **Idle means idle.** 0.0% against 7.9%. A mock that answers a request and then stops computing is not a battery drain.
- **The footprint is a build gate.** The build fails above 100 MB, 5 seconds of startup or 1% idle CPU. A number in a README is a claim; a number in a test is a constraint.
- **The gate runs locally, offline, with no runner.** The laptop was already on.

None of this is virtue signalling. It is that the local option is nearly always the better engineering option, and once you notice that, the environmental argument turns out to be a consequence rather than a constraint.

## The thing I would like to see

A build system where the *default* is local, deterministic, and offline, and remote execution is the exception you reach for deliberately rather than the substrate everything runs on.

We have spent a decade moving compute into the data centre and treating that as neutral. It was never neutral — it was a decision about where the energy came from and who paid for it, made at a scale where nobody had to justify it.

The interesting part of the next decade is the tooling that makes the local option good enough that the remote option has to earn its place.

I have been building in that direction for a while now — [CI Kit](https://github.com/omeiza-workspace/ci-kit) and [api-mock-services](https://github.com/omeiza-workspace/api-mock-services) are both attempts at it. If you are building in the same direction, I would genuinely like to read what you are doing.]]></content:encoded>
      <category>Sustainability</category>
      <category>Performance</category>
      <category>Cost</category>
      <category>Tooling</category>
    </item>
  </channel>
</rss>
