Pipeline Guard
One check in your release pipeline, fixed price.
Name one failure in your release pipeline. We build one check in your own pipeline that catches it, proven on test cases we agree before you sign.
- €4,900 fixed, ex VAT
- Nothing invoiced at signing
- The failure shown red by working day 10
Pull request: bulk discount
1 check failed- Build
- Unit tests
- change-guard Stopped
The new or changed test files also pass on the base commit without this change, so they would not catch the change being wrong.
What to do: add an assertion on the behaviour this change introduces, so the test fails on the base.
Three failures
Which failure do you want stopped?
A change merges with no test that would catch it
A change was merged and shipped although no test would have failed if it was wrong. A person or a coding agent wrote it, and review was a glance.
The change guardMac build machines drift, or a certificate runs out
Your Mac build machines run different versions of macOS, Xcode or CocoaPods and a build breaks on one of them. Or a signing certificate runs out and the release fails on the day you need it.
The Apple guardsA hotfix or configuration change skips your checks
An urgent fix went to production around the checks a normal release gets. Or a configuration change went out that nobody else looked at, and monitoring said all was well.
The hotfix and configuration guardsHow you pay
The offer
You pick the one failure you want stopped. We build one check in your own pipeline that catches it, proven on test cases we agree before you sign. The price is fixed: EUR 4,900 excluding VAT.
Nothing until Red, the rest on green
You sign
€0
Nothing is invoiced at signing.
Red
First half
Within 10 working days of access we cause the failure on purpose and show it failing in your own pipeline. If we cannot, nothing is invoiced and the work ends.
Green
Second half
Every test we agreed before signing passes. Handover is planned for working day 30 and promised by working day 45.
You may stop after Red. You keep the test cases and the written design, and you owe nothing more.
Price
Price and terms
€4,900
ex VAT, one guard
- Price
- EUR 4,900 excluding VAT, fixed, for one guard, in one statement of work.
- Outside the EU
- USD 5,600, under Dutch law.
- Invoices
- Due in 14 days. Nothing at signing.
- If a test fails at acceptance
- We keep working at no charge for up to 20 more hours within 20 working days. If it still fails, you keep everything delivered and the second half is never invoiced.
- Warranty
- For 30 days after acceptance we repair defects in the guard at no charge, up to six hours of work, within 3 working days of your written report.
- Skip step
- If the guard ever stops a release you need, your engineer skips it in one recorded step. You never wait for us.
The terms in full
You pay nothing when you sign. Within 10 working days of getting access, we cause the failure you named on purpose and show it failing, red, in your own pipeline, in a recorded run. Only then do we invoice the first half. If we cannot show it failing in your pipeline, nothing is invoiced and the work ends. Once Red is shown, you may stop there. You keep the test cases and the written design, and you owe nothing more. We invoice the second half when every test we agreed before signing passes, or when 10 working days pass after our ready notice without you naming a failed test in writing. We plan to hand the guard over for acceptance on working day 30 and promise the handover by working day 45, not counting days we wait for access or reviews. If a test fails at acceptance, we keep working at no charge for up to 20 more hours within 20 working days. If it still fails after that, you keep everything delivered, the second half is never invoiced and the work ends. There is no refund and no promise about future incidents: a guard reduces a failure and cannot rule it out.
Acceptance
The four tests
Every guard is accepted on the same four tests, with the numbers filled in before signing:
Catch
Every seeded bad case is stopped by the pipeline with a message that names the cause, twice in a row.
Pass
Ten normal runs in a row on an agreed branch go through with no false stop caused by the guard. We may trigger these runs ourselves.
Cost and record
The guard adds no more than the agreed time to the median run (three minutes by default, five for a change guard). Every run leaves one line in a log the client owns. The guard can be skipped only through one documented step that records who skipped it and why.
Ownership
The client's engineer follows the runbook, triggers one seeded case and restores green without us. A recording is enough. If no engineer runs it within 10 working days of the ready notice, T4 counts as passed.
Scope
What every guard includes
One guard covers one named failure in one pipeline: one shared pipeline template and every repository that uses it unchanged, or one repository, or one build fleet of up to ten machines.
You get
- Three to five seeded cases
- A one-page design note
- The check as pull requests through your normal review
- A runbook
- An upkeep sheet
- A recording of the acceptance run
- A list of up to three other failures we noticed
Report-only until acceptance
The guard reports what it would stop instead of stopping it, but a setup error, such as a configuration it cannot read, can still fail the run. The failure is caused only on a target that is not production, and every run we trigger is checked for its line in a log you own. Blocking mode on the default branch counts as production use.
No admin rights
The check reaches your systems only as pull requests your own engineers review and merge, and our access can be removed in one documented step.
Pick one
The guards
Each guard is EUR 4,900 excluding VAT. You pick the one you need.
The change guard
EUR 4,900A change to the named paths must bring a test that fails without it.
- The guard
- A required check on the paths named in the statement of work. A change to those paths must bring a new or changed test, and that test must fail on the code before the change and pass with it. The paths and an exempt list (documentation, configuration, dependency bumps) are agreed before you sign, and only the changed test files run against the code before the change, so large suites stay inside the time budget.
- Runs today
- On GitHub Actions, for Python, TypeScript, JavaScript, Java, Kotlin, Go, C#, PHP, Ruby and Swift.
- Seeded cases
- A behaviour change with no test (stopped), a change whose new test also passes without the change (stopped), a good change (merges), an exempt change (merges untouched), the skip step used once (merges and is logged).
- Not included
- Writing missing tests, repairing a test suite, AI code review, agent permissions and token scopes, a second repository.
The Apple guards
EUR 4,900 eachTwo separate guards: the certificate guard and the drift guard. You pick the one you need.
- The certificate guard
- Every run reads the signing certificates it will use, stops before the build if one has expired or was issued by Apple's original Developer ID authority (which expires on 1 February 2027), and warns from 30 days before expiry. New certificates are valid for one year, so the runbook carries the renewal steps.
- The drift guard
- One pinned definition of the toolchain lives in your repository. A build host that differs refuses to build and says what differs.
- Seeded cases
- A test certificate with fewer than 30 days left, one host set to another Xcode or CocoaPods version.
- Not included
- Re-signing or repackaging, vendor packages, Apple's notary queue and account problems, upgrading the hosts, changes to device management. We never hold a key and need no remote login: the check runs through your own build agents.
- Related work
- Signing and delivery to managed Apple devices, 2022 to 2025, shown in a recorded walkthrough and named in one recommendation. Our work on keeping Mac build hosts in step is thinner than our signing work.
The hotfix and configuration guards
EUR 4,900 eachTwo separate guards: every path to production runs the agreed checks, and a configuration change is checked after deployment.
- The hotfix guard
- Every path to production, the emergency path included, runs the agreed regression stage, and a deploy that did not pass it refuses to start. It must fit the agreed time budget, and if it ever stops a release you need, your engineer skips it in one recorded step.
- The configuration guard
- After a change to the named configuration paths is deployed, one automated check must pass or the release is marked failed. The change also cannot merge without a second approver who is not its author.
- Seeded cases
- A hotfix pushed with the test stage skipped (stopped), a hotfix with green tests (passes inside the time budget), a configuration change approved only by its author (stopped).
- Not included
- On-call work, incident response, changes to how you deploy, production changes by us. Every change we make reaches you as a pull request that your engineers review and merge.
Proof
What we can show
Apple signing and notarisation in a delivery pipeline for apps on managed devices, 2022 to 2025, as a contractor at Nike European HQ. A recorded walkthrough shows the work.
A signed reference from the engineer's former group leader at ASML, for self-service CI work in 2021 and 2022.
Five LinkedIn recommendations from Nike colleagues, two of them from people who managed the work directly, and one attributed quote on this site.
When not to buy
- If your own engineer can close the failure in a day once it is named, do that instead.
- If you have only one or two in-house installer packages to re-sign, your team can do that itself. The certificate guard is for pipelines where signing certificates expire every year and a missed date stops a release.
Process
How we work
A 20-minute call
You name the failure and the last time it happened.
One page before you sign
The scope, the tests written as outcomes, the dates and the price. If it does not fit, we say so.
Red by working day 10
We show the failure failing in your own pipeline.
Handover by working day 30 to 45
Accepted on the four tests.
About 6 hours of your team
Two pull request reviews, one setting and the handover run. This does not count your own supplier or security review of our access.
One statement of work
One per guard, with no master agreement. Before kickoff we need your supplier record and a purchase order number.
Everything stays with you
The check arrives as pull requests in your own repositories and stays there. Its run record goes to a log you own.
| Step | When |
|---|---|
| The clock starts | At access, due within three working days of kickoff |
| Red | By working day 10 |
| Handover for acceptance | Planned for working day 30, promised by working day 45 |
| Rework | Up to 20 hours inside 20 working days |
The clock pauses while an input from your side is missing. If you have not named a failed test in writing within 10 working days of our ready notice, the guard counts as accepted.
A second repository
The same guard on a second repository or build fleet that needs its own work: EUR 1,900 excluding VAT, on the same terms.
€1,900ex VAT, same guard
Questions
Often, yes. If one of your engineers can close the failure in a day once it is named, you should not buy it from us. What usually takes longer is the part around the check: the cases that should not stop a merge, the skip step with a record, and a runbook your team can follow without us.
Coverage shows that a line ran. It does not show that a test would notice the line being wrong. The change guard checks that the new or changed test fails on the code before the change and passes with it.
That is the right question. Where your test runner writes a per-test report, the guard reads it test by test. A failed assertion on the old code counts as proof. An error that only says the new function is missing does not: the guard then runs a probe, in which each function the change adds or gives a new parameter keeps its name while its body is replaced by an empty return, and for each one at least one of the new or changed tests has to notice. A changed body is not probed; for that, the run on the old code does the job. It is built in for Python and has run for real with two test runners, Python's unittest and pytest. For other languages it can use a mutation tool your team already runs, which we have not yet tried with a real tool; without one, such a change passes with a note for the reviewer, or is stopped if you choose that before signing. It runs on GitHub Actions today, for Python and nine other languages. The guard shows that a test depends on the change, never that the assertion checks the right thing: someone still reads the test.
Before signing we agree which paths it covers and an exempt list, for example documentation, configuration and dependency bumps. A change that only renames or moves a file without changing its content, or only changes whitespace in a Python file without changing the code itself, passes automatically and is logged; any other refactor, a renamed function included, goes through the one recorded skip step, with its reason in the log. A test that gives different results on two runs of the old code is named as flaky and never counted as proof: the change is stopped until the test is fixed, set aside or skipped in that recorded step. One of the acceptance tests is ten normal runs in a row with no false stop caused by the guard, and until acceptance it only reports. If it stops a normal run for a reason the guard caused, that is a defect we repair under the warranty. We do not repair your test suite itself: a flaky test stays your test.
The guard is built so you never wait for us. If it stops a release you need, your engineer skips it in one recorded step, and acceptance includes your own engineer breaking and restoring it alone from the runbook. If we could not finish, you would keep everything delivered, and the second half is only ever invoiced on acceptance. Outside the warranty we offer no on-call service and no fixed response time; within the warranty we repair a defect within 3 working days of your written report.
No admin rights. The check reaches you only as pull requests your engineers review and merge, and the failure is caused only on a target that is not production. No production personal data, nothing copied out, and our access can be removed in one documented step. We will sign your NDA next to the statement of work.
So a finished job cannot stay open forever, in either direction. You stay in control: naming one failed test in writing within those 10 working days stops acceptance, and we keep working on it at no charge for up to 20 hours within 20 working days. The runs we may trigger are on the agreed branch, in report-only mode, and each one is checked for its line in your own log.
The first result you see is the Red run, by working day 10 after access. We plan the handover for working day 30 and promise it by working day 45, not counting days we wait for access or reviews. We would rather promise a date we can keep.
One guard can be one shared pipeline template and every repository that uses it unchanged. The same guard on a further repository that needs its own work is EUR 1,900.
Upgrading the hosts is not part of the drift guard. Bringing the machines onto the same versions by script would be a separate, second guard at the same price.
The second-approver half may well be a setting you already have. The part that is work is the automated check after deployment that marks the release failed when it does not pass, proven on seeded cases. If you already have both, do not buy it.
Talk to the engineer
"As an engineer, I know the challenges in software delivery from both business and technical views."