Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions content/labs/spec-drift/lab.mdx
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ topic: "spec"
preview: "gate"
tags: ["spec-driven", "quality"]
writing: "from-intent-to-proof"
themes: ["quality-test-strategy", "delivery-operations"]
---

The manifest on the left is the source of truth. The gate on the right is not
Expand Down
1 change: 1 addition & 0 deletions content/labs/test-pyramid/lab.mdx
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ date: "2026-09-18"
topic: "quality"
preview: "bars"
tags: ["testing", "ai"]
themes: ["quality-test-strategy"]
---

When code is expensive, the pyramid is wide at the bottom because unit tests
Expand Down
1 change: 1 addition & 0 deletions content/labs/workflow-stepper/lab.mdx
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ date: "2026-09-17"
topic: "orchestration"
preview: "process"
tags: ["camunda", "orchestration", "order management"]
themes: ["workflow-orchestration"]
---

A submitted quote doesn't become one big transaction. It is decomposed into
Expand Down
69 changes: 69 additions & 0 deletions content/work/goldpath.mdx
Original file line number Diff line number Diff line change
@@ -0,0 +1,69 @@
---
title: "A golden path for enterprise .NET, not another framework"
summary: "Goldpath: composable packages, templates and checks that give .NET teams the plumbing every enterprise system needs, with one manifest as the source of truth."
sector: "Developer tools"
role: "Author"
themes: ["architecture-integration", "quality-test-strategy"]
kind: "open-source"
aiNative: true
period: "2026 — now"
date: "2026-07-12"
stack: [".NET 10", ".NET Aspire", "PostgreSQL", "Quartz", "Stryker", "OpenAPI", "AsyncAPI"]
outcomes:
- { value: "23", label: "packages", countTo: 23 }
- { value: "13", label: "architecture decisions", countTo: 13 }
- { value: "1100+", label: "tests", countTo: 1100 }
---

## Context

Every enterprise .NET team builds the same things again: idempotency, locking,
an audit trail, background jobs, messaging, bulk processing. Each version has
its own bugs. And the spec, the contracts and the code drift apart the moment
the first deadline arrives.

Goldpath is a paved road for that. It is not a framework: it configures
Microsoft's own building blocks instead of wrapping them, so a team can leave
the road at any point.

[GitHub](https://github.com/qorpe/goldpath)

<LayerStack title="How the pieces fit">
<Layer label="Manifest" detail="source of truth" note="What the service is and what it must guarantee, with its OpenAPI and AsyncAPI contracts." />
<Layer label="Packages" detail="23 NuGet packages" note="Idempotency, locking, audit, jobs, messaging, bulk, approvals and more. Take only what you need." />
<Layer label="Checks" detail="SpecDrift" note="A deterministic check that the manifest and the repository still agree. No model involved." />
<Layer label="Reference app" detail="nightly" note="A sample finance app built every night against the published packages." />
</LayerStack>

## The decisions

- **The manifest is the single source of truth.** Contracts, checks and
generated docs all follow from it.
- **Configure Microsoft, never wrap it.** Less to learn, nothing to unlearn.
- **AI stays in the development layer.** It helps write and change code. The
runtime libraries contain no AI; that is an opt-in module.
- **Standards are executable.** A rule that isn't checked by a tool is a
suggestion. The docs are generated, so they can't go stale.
- **Three approvals no tool can skip.** The spec is approved by the business,
the merge request by a developer, the cut-over by operations. Everything an
agent produces arrives as a merge request.

## One proof, in detail

The question every payments architect asks first: what happens when a node dies
in the middle of a batch? A test in CI answers it on every pull request, with
two real executor processes and a real PostgreSQL.

<Flow
title="kill -9 in the middle of a payment batch"
steps="Claim: row marked before it runs | Kill: the executor dies | Detect: the other node notices | Resume: from the last checkpoint | Repair: interrupted rows are held"
notes="Every row in a chunk is marked as claimed in the database before its handler runs. | The test finds the node that is actually paying and kills its whole process tree. | The scheduler's cluster check-in marks the dead node, and the job fires again on the survivor. | The run continues. Completed chunks never run twice. | A row that was claimed but never confirmed isn't sent again. It goes to a repair queue with instructions: check the downstream state, then replay."
/>

No payment goes out twice. The test proves it; nobody has to believe it.

## How I built it

I wrote it with AI, inside the same rules it gives to its users: a manifest
first, deterministic checks, tests that must fail before the change, and
mutation testing to show the tests actually catch mistakes.
73 changes: 73 additions & 0 deletions content/work/mockifyr.mdx
Original file line number Diff line number Diff line change
@@ -0,0 +1,73 @@
---
title: "A mock server that is done only when it matches the reference"
summary: "Mockifyr, a self-hosted API mocking and integration sandbox in .NET. Every behaviour it copies is checked against a running WireMock before it counts as done."
sector: "Developer tools"
role: "Author"
themes: ["quality-test-strategy", "architecture-integration"]
kind: "open-source"
aiNative: true
period: "2026 — now"
date: "2026-07-01"
stack: [".NET 10", "ASP.NET Core", "Testcontainers", "PostgreSQL", "Redis", "Kafka", "Docker", "Helm"]
outcomes:
- { value: "63", label: "releases", countTo: 63 }
- { value: "1500+", label: "tests", countTo: 1500 }
- { value: "15", label: "architecture decisions", countTo: 15 }
---

## Context

Enterprise systems depend on downstream systems you can't call from a test:
billing, inventory, a partner's API, an SMS gateway. You mock them, and then
you trust the mock. I wanted a mock server in .NET, with its own codebase, that
speaks the protocols these systems actually use and can be handed to a partner
as a sandbox. And I wanted a way to know it behaves correctly, not a feeling
that it does.

[mockifyr.qorpe.com](https://mockifyr.qorpe.com) ·
[GitHub](https://github.com/qorpe/mockifyr)

<SystemMap
title="One engine, many ways in"
legend="No I/O, no transport"
columns="Protocols: HTTP; gRPC; GraphQL; WebSocket; Email and SMS; Kafka and AMQP | Facades: In-process library; HTTP server; Admin API; Dashboard | Core: *Match the request; *Build the response; *Directives: delay, fault, proxy | Storage: In memory; PostgreSQL; Redis; LiteDB"
/>

## How "done" is decided

A feature that copies WireMock's behaviour isn't done when it looks right. It
is done when the same requests produce the same responses in both.

<Flow
title="The differential check"
steps="Generate: many requests | Send: to both servers | Compare: responses | Done: when nothing differs"
notes="Inputs are generated, not hand-picked, so edge cases show up without anyone thinking of them. | The same requests go to Mockifyr and to a real WireMock running in a container. | Status, headers and body are compared, byte for byte or by meaning. | Any difference is a failing test. The work ends when the diff is empty."
/>

Where no reference exists, a real client drives the feature instead: a real
mail client for SMTP, the official Twilio SDK for SMS, a real gRPC client for
gRPC.

## The decisions

- **The core does no I/O.** Delay, fault and proxy are directives the core
returns; calls to the outside world happen at the edges. That is what makes
the differential check possible.
- **Tenants are in the model from day one.** One process serves many teams or
partners, each with its own stubs, keys and quotas. Adding this later would
have meant rewriting the engine.
- **Memory first, storage optional.** Requests are always served from memory.
PostgreSQL, Redis or LiteDB are written through when data has to survive a
restart or be shared between replicas.
- **Every decision is written down.** Fifteen decision records and a parity
document for each area of behaviour, including what is deliberately left out.

## How I built it

I wrote it with AI. The AI never judged its own work: the architecture rule is
that only the running reference decides whether a behaviour is correct.

## Outcome

Sixty-three releases, one container image for amd64 and arm64, a Helm chart
that runs on OpenShift, and more than 1,500 tests.
1 change: 1 addition & 0 deletions content/writings/from-intent-to-proof.mdx
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@ lang: "en"
tags: ["manifesto", "spec-driven", "quality", "ai"]
featured: true
draft: true
themes: ["delivery-operations", "quality-test-strategy"]
---

> Draft. The structure is final; the words are not.
Expand Down
33 changes: 0 additions & 33 deletions content/writings/mockifyr-neden.mdx

This file was deleted.

74 changes: 74 additions & 0 deletions content/writings/why-i-wrote-mockifyr.mdx
Original file line number Diff line number Diff line change
@@ -0,0 +1,74 @@
---
title: "Why I wrote Mockifyr: done means a green diff"
description: "A mock server is only useful if it behaves like the thing it copies. So I stopped asking whether it looked right and started comparing it with the real one."
date: "2026-09-30"
lang: "en"
tags: ["testing", "mocking", ".net"]
series: "Test strategy that holds"
seriesOrder: 1
featured: true
themes: ["quality-test-strategy"]
---

Every integration test that uses a mock makes a quiet assumption: the mock
behaves like the real thing. When it doesn't, the test passes and production
fails, and nobody finds out until a customer does.

I wrote [Mockifyr](https://mockifyr.qorpe.com) because I needed a mock server
in .NET, with its own codebase, that I could hand to a team or a partner as a
sandbox. It copies the behaviour of WireMock, the most widely used mock server.
The hard part wasn't writing it. The hard part was knowing it was right.

## Looking right is not a test

The usual way to build something like this is to read the reference
documentation, write the feature, write a few tests for the cases you thought
of, and move on. Every step of that depends on your own understanding. If you
misread how the reference handles an empty array or a missing header, your code
and your tests will agree with each other, and both will be wrong.

It gets worse when code is cheap to write. With AI, I could produce a feature
and its tests in minutes. Tests written by the same hand, human or not, from the
same understanding, prove very little.

## Ask the real one

So the rule became: the only thing that decides whether Mockifyr is correct is a
running WireMock.

<Flow
title="The loop behind every feature"
steps="Generate: many requests | Send: to both servers | Compare: the responses | Keep: every failure as a test | Fix: until the diff is empty"
notes="Inputs come from a generator with a fixed seed: empty values, long values, unicode, missing and extra fields, different array orders. Nobody has to think of the edge cases. | The same stub is loaded into Mockifyr and into a real WireMock running in a container, and the same request goes to both. | Status, headers and body are compared. Any difference means Mockifyr is wrong. | A failing input is added to the regression suite, so the suite grows with every bug found. | The feature is done when the two servers give the same answers. Not before."
/>

That changes what "done" means. It isn't "I believe it works" or "the tests I
wrote pass". It is "the reference and my code give the same answers to inputs
I didn't choose".

## What the loop needs from the design

You can only compare two systems if you can drive one of them precisely. That
shaped Mockifyr's core from the first commit: it does no I/O. Delays, faults and
proxying are instructions the core returns, not things it does. Calls to the
outside world happen at the edges. A pure core is easy to put side by side with
anything.

## Where the loop stops

A byte diff only catches what it can compare. Timing, socket-level faults, TLS
handshakes and concurrency don't show up in it, so they are tested separately.
Some features have no WireMock equivalent at all, such as SMTP, SMS or gRPC.
For those, a real client drives the feature instead: a real mail client, the
official Twilio SDK, a real gRPC client. When there is no oracle, the next best
thing is the software people actually use.

## The general point

This isn't about mock servers. Whenever you rebuild something that already
exists, whether it's a legacy system, a library or a service, you already have
the best test you'll ever get: the old one. Run both, compare the answers, and
let the difference tell you when you are done.

With AI writing more of the code, this matters more, not less. The model can
write the feature. It shouldn't be the one who decides it works.
16 changes: 16 additions & 0 deletions src/app/work/[slug]/page.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,8 @@ import { Toc } from "@/components/writings/toc";
import { renderMdx } from "@/lib/mdx";
import { extractHeadings } from "@/lib/writings";
import { getLabsBySlugs } from "@/lib/labs";
import { getAllWritings } from "@/lib/writings";
import { PostRow } from "@/components/writings/post-row";
import { getProgrammeParts, getWorkBySlug, getWorkSlugs } from "@/lib/work";
import { pageMetadata } from "@/lib/seo";

Expand Down Expand Up @@ -54,6 +56,9 @@ export default async function WorkStudyPage({
work.programme ? getWorkBySlug(work.programme) : null,
]);
const themes = work.themes.map(getTheme).filter((x) => x !== undefined);
const writings = (await getAllWritings()).filter((w) =>
(w.themes ?? []).some((t) => work.themes.includes(t)),
);
const headings = extractHeadings(work.content);

return (
Expand Down Expand Up @@ -164,6 +169,17 @@ export default async function WorkStudyPage({
</section>
)}

{writings.length > 0 && (
<section className="mt-14">
<h2 className="mb-2 text-h3 font-medium">{t("relatedWriting")}</h2>
<div className="flex flex-col">
{writings.map((post) => (
<PostRow key={post.slug} post={post} />
))}
</div>
</section>
)}

{labs.length > 0 && (
<section className="mt-14">
<h2 className="mb-4 text-h3 font-medium">{t("tryIt")}</h2>
Expand Down
16 changes: 15 additions & 1 deletion src/app/writings/[slug]/page.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,8 @@ import {
type WritingMeta,
} from "@/lib/writings";
import { articleJsonLd, articleMetadata } from "@/lib/seo";
import { getWorkInThemes } from "@/lib/work";
import { WorkCard } from "@/components/work/work-card";

/** A table of contents earns its space from three sections up. */
const TOC_MIN_HEADINGS = 3;
Expand Down Expand Up @@ -56,9 +58,10 @@ export default async function WritingPage({
day: "numeric",
}).format(new Date(post.date));

const [seriesPosts, adjacent] = await Promise.all([
const [seriesPosts, adjacent, practice] = await Promise.all([
post.series ? getSeriesPosts(post.series) : Promise.resolve([]),
getAdjacentWritings(slug),
getWorkInThemes(post.themes ?? []),
]);
const headings = extractHeadings(post.content);
const showToc = headings.length >= TOC_MIN_HEADINGS;
Expand Down Expand Up @@ -164,6 +167,17 @@ export default async function WritingPage({
{content}
</div>

{practice.length > 0 && (
<section className="mt-14">
<h2 className="mb-4 text-h3 font-medium">{t("inPractice")}</h2>
<div className="grid gap-4 sm:grid-cols-2">
{practice.map((item) => (
<WorkCard key={item.slug} work={item} />
))}
</div>
</section>
)}

<AuthorCard />
<NewsletterBox />
<PostNav newer={adjacent.newer} older={adjacent.older} />
Expand Down
10 changes: 6 additions & 4 deletions src/i18n/messages/en.json
Original file line number Diff line number Diff line change
Expand Up @@ -68,8 +68,8 @@
{
"title": "Quality & test strategy",
"desc": "Tests strong enough to decide what reaches production.",
"href": "/labs/test-pyramid",
"proof": "test pyramid"
"href": "/work/mockifyr",
"proof": "green diff"
},
{
"title": "Delivery & operations",
Expand Down Expand Up @@ -110,7 +110,8 @@
"themes": "Practice areas",
"partOf": "Part of",
"parts": "The parts",
"featured": "Featured work"
"featured": "Featured work",
"relatedWriting": "Writing in this area"
},
"labs": {
"title": "Labs",
Expand Down Expand Up @@ -139,7 +140,8 @@
"older": "Older",
"copy": "Copy code",
"copied": "Copied",
"writtenBy": "Written by"
"writtenBy": "Written by",
"inPractice": "In practice"
},
"openSource": {
"title": "Open source",
Expand Down
Loading
Loading