diff --git a/content/work/business-rules.mdx b/content/work/business-rules.mdx
new file mode 100644
index 0000000..049e3b9
--- /dev/null
+++ b/content/work/business-rules.mdx
@@ -0,0 +1,44 @@
+---
+title: "Business rules as data, one engine for UI and backend"
+summary: "Hundreds of eligibility, compatibility and validation rules kept as data and evaluated by one engine, so the screen and the server always give the same answer."
+sector: "Telco"
+role: "Lead Developer"
+themes: ["domain-modeling-rules"]
+kind: "client"
+programme: "telco-service-orchestration"
+period: "2025 — now"
+date: "2025-10-01"
+stack: [".NET", "ASP.NET Core", "PostgreSQL", "Vue 3", "Vue Flow"]
+---
+
+## Context
+
+Whether a product can be added to a quote, combined with another, or changed
+on an existing order depends on hundreds of rules. When the UI checks one
+version of a rule and the backend another, users see one answer on screen and
+get a different one when they submit. And every rule written in code waits for
+a release when the business changes it.
+
+## How a rule works
+
+A rule is a row, not code. The engine reads it and runs it.
+
+
+
+## The decisions
+
+- **One engine.** The UI doesn't have its own copy of the rules. It calls the
+ same engine the backend uses, so the answer is the same everywhere.
+- **Rules are data.** A rule has a lifecycle and validity dates. A rule built
+ from existing commands is added or changed without a deployment.
+- **Commands are code.** When a rule needs something new to read or set, it
+ becomes a new command: written once, reviewed and tested like any other code,
+ then reusable by every rule.
+
+## My part
+
+I led the team that built it.
diff --git a/content/work/generic-user-tasks.mdx b/content/work/generic-user-tasks.mdx
deleted file mode 100644
index 20fd169..0000000
--- a/content/work/generic-user-tasks.mdx
+++ /dev/null
@@ -1,40 +0,0 @@
----
-title: "User tasks without a screen per task"
-summary: "A framework where hundreds of human steps in order workflows share one handler pipeline and one form renderer, so adding a task is mostly configuration."
-sector: "Telco"
-role: "Lead Developer"
-themes: ["workflow-orchestration", "architecture-integration"]
-kind: "client"
-programme: "telco-service-orchestration"
-period: "2025 — now"
-date: "2025-06-26"
-stack: ["Camunda 8", ".NET", "Vue 3", "Vuetify", "TypeScript"]
----
-
-## Context
-
-Order workflows stop at hundreds of points for a person: confirm technical
-details, choose equipment, approve a change. A screen and an endpoint for each
-would have meant hundreds of near-identical forms drifting apart.
-
-
-
-## The pattern
-
-- **Generic by default, specific by exception.** One pipeline for every task; a
- dedicated handler only where the data demands it.
-- **Forms are data.** The UI renders from field metadata through a component
- registry, so screens stay consistent and a fix in the renderer reaches every
- task.
-- **Adding a task is configuration.** Define its fields; write code only for the
- exception.
-
-## My part
-
-I designed and built the framework: handler resolution and the pipeline, the
-worklist and task stepper, and the registry-driven form renderer. The team built
-the task pool on it and moved the field definitions into a database catalog.
diff --git a/content/work/internal-learning-platform.mdx b/content/work/internal-learning-platform.mdx
index 076233f..c40b87b 100644
--- a/content/work/internal-learning-platform.mdx
+++ b/content/work/internal-learning-platform.mdx
@@ -1,6 +1,6 @@
---
title: "One engineer, every layer, three months to production"
-summary: "An internal training platform built AI-natively: backend, frontend, database, DevOps and operations owned by one engineer, delivered in a governed cycle."
+summary: "An internal training platform I built alone with AI: backend, frontend, database, DevOps and operations, live in three months and running without trouble since."
sector: "Corporate learning"
role: "Founder & engineering lead"
themes: ["delivery-operations", "quality-test-strategy"]
@@ -18,56 +18,74 @@ featured: true
## Context
-An organization needed one place for its training: a programme catalogue,
-sessions, requests, approvals, attendance and certificates, replacing an older
-system whose data was migrated in. A product owner shaped the requirements and
-the screen mockups. Every engineering role was mine.
+The organization needed one place for its training: a programme catalogue,
+sessions, requests, a two-step approval, attendance and certificates, replacing
+an older system whose data we migrated. A product owner shaped the requirements
+and the screen mockups. All the engineering was mine.
-## The system
-
-- **Application:** .NET 10 Clean Architecture with CQRS on PostgreSQL, a
- separate worker for scheduled jobs, and a Next.js front end behind a BFF, so
- tokens never reach the browser.
-- **Integration:** single sign-on with Entra ID, user sync from the HR system,
- an email queue with retries.
-- **Delivery:** a self-hosted GitLab with its own runner, CI/CD to separate
- development, test and production environments, tagged releases with
- generated notes.
-- **Operations:** structured logs kept in the database and archived on a
- schedule; tiered backups with a stated recovery point and restores that are
- rehearsed; a daily read-only health check of production.
-- **Rules:** every domain rule written as a numbered invariant, each tied to a
- test, with the reasoning recorded as a decision record.
-
-## How a task moves
-
-Speed came from the cycle, not from skipping steps. Every change passes the
-same gates, with a review between each.
-
-
-
+## Who does what
-## Proof before go-live
+AI writes most of the code. It doesn't decide what the code should do, and it
+doesn't decide when a change is done.
-Load- and stress-tested up to 300 concurrent users with no server errors and a
-95th percentile under 400 ms. Scanned with SonarQube, OWASP ZAP and a
-dependency audit.
+| Step | The agent | Me | Checked by |
+|---|---|---|---|
+| Start | Reads the issue, the logs and the data, and writes down the cause | I agree with the cause, or with the approach for a feature | |
+| Test | Writes a test that fails without the change | I check it tests the right thing | The test must fail before the fix |
+| Build | Writes the code and updates the docs in the same commit | I review the change | Unit and integration tests on a real PostgreSQL |
+| Verify | Drives the feature in a browser with Playwright | I compare it with the rules | End-to-end tests |
+| Ship | Opens a merge request with the evidence | I review and merge | CI, then development, test and production |
+
+## How the repository keeps it honest
+
+- **A start file for any agent or new developer.** It says what not to break
+ and in which order to read: the business rules, a generated map from each
+ feature to its code and docs, the delivery cycle, the decision records, and
+ only then the code.
+- **Numbered rules.** The core business rules are written as invariants, such
+ as "the waitlist is filled by an admin, never by the system". Each has a
+ test, and a rule and its test can only change together.
+- **The cycle is checked in.** A skill in the repository walks every change
+ through the same steps. It has no rules of its own; it only enforces the
+ order. A step counts only when it was actually run.
+- **Production is read-only.** The agent can read logs and query data. It
+ can't write anything.
+
+When a waitlist bug reached production, the fix went through the same steps
+and left three things behind: a decision record, a numbered rule and a test.
+That bug can't come back without a test failing first.
+
+## Running it
+
+- A self-hosted GitLab with its own runner, and CI/CD to separate development,
+ test and production environments.
+- Tagged releases with generated release notes.
+- Structured logs in the database, archived on a schedule.
+- Backups in tiers with a stated recovery point, and a weekly restore of
+ production data into development, so restores are practised, not assumed.
+- A daily read-only health check of production.
+
+
+
+## Before go-live
+
+Load- and stress-tested up to 300 concurrent users: no server errors, 95th
+percentile under 400 ms. Scanned with SonarQube, OWASP ZAP and a dependency
+audit.
## Outcome
-In production since the third month and used by around 400 people, with
-nothing since go-live beyond bug fixes and cosmetic changes. More than 2,000
-automated tests guard it, and when something does go wrong it ends as a rule, a
-test and a decision record.
+Live since the third month and used by around 400 people. Since go-live the
+changes have been bug fixes and cosmetic polish, nothing more.
diff --git a/content/work/order-orchestration.mdx b/content/work/order-orchestration.mdx
index 31921a5..dc4c5cd 100644
--- a/content/work/order-orchestration.mdx
+++ b/content/work/order-orchestration.mdx
@@ -1,42 +1,63 @@
---
-title: "One process per order"
-summary: "How a submitted quote becomes product orders, each running as its own workflow, with downstream systems answering asynchronously and orders that can still be cancelled mid-flight."
+title: "One process per order, and the people in it"
+summary: "Each product order runs as its own workflow: downstream systems answer late, people step in at hundreds of points, and an order can still be cancelled while it runs."
sector: "Telco"
role: "Lead Developer"
themes: ["workflow-orchestration"]
kind: "client"
programme: "telco-service-orchestration"
period: "2025 — now"
-date: "2025-05-06"
-stack: ["Camunda 8", ".NET", "ASP.NET Core", "Refit", "PostgreSQL"]
+date: "2025-06-01"
+stack: ["Camunda 8", ".NET", "ASP.NET Core", "Refit", "Vue 3", "PostgreSQL"]
---
## Context
-An order for a business customer touches network inventory, work orders,
-billing and people who confirm technical details, and some of those systems
-answer days later. Every order needed an explicit state, a way to survive slow
-downstream systems, and a precise answer to "can this still be cancelled?".
+A business order touches network inventory, work orders, billing and people
+who confirm technical details. Some of those systems answer days later. Every
+order needs its own state, has to survive slow downstream systems, and needs a
+clear answer to "can this still be cancelled?".
+
+Try it: step an order through its process, then cancel it before and after the
+milestone.
-## The pattern
-
-- **The process is chosen by data.** A decomposition table, keyed by service and
- change type, says which workflow each product order runs. A new scenario is a
- row and a process model, not new code.
-- **One workflow per product order.** Each runs as its own Camunda 8 instance and
- calls back into the services for the business logic, so the model stays about
- the flow.
-- **Late answers find their order.** Outbound requests carry a message id; a
- downstream callback is correlated to the waiting process by it, however late
- it arrives.
-- **Change is allowed up to a milestone.** The process marks the points after
- which cancelling or changing is no longer safe. Before them a request is
- applied to the running order; after them it is refused with a reason.
+## How it works
+
+- **One workflow per product order.** A submitted quote is split into product
+ orders, and each runs as its own Camunda 8 process. A table decides which
+ process a product order runs; the splitting itself is a small strategy per
+ scenario, so each new scenario stays isolated.
+- **The business logic stays in .NET.** The process calls back into the
+ services to create service orders and update the order, so the process model
+ only describes the flow.
+- **Late answers find their order.** Every outbound request carries a message
+ id. When a downstream system calls back, the answer is matched to the waiting
+ process by that id, however late it comes.
+- **Change is allowed up to a milestone.** The process marks the point after
+ which cancelling or changing isn't safe anymore. Before it, the request is
+ applied to the running order. After it, the request is refused with a reason.
+
+## The people in the process
+
+Across all order types, the processes stop at hundreds of points for a person:
+confirm technical details, pick equipment, approve a change. Building a screen
+for each one would have given us hundreds of forms drifting apart. So every
+user task goes through one pipeline.
+
+
+
+Adding a task is mostly configuration, and a fix in the pipeline reaches every
+task at once.
## My part
-I built the layer the platform uses to talk to Camunda 8: typed clients over its
-REST API for process instances, messages, user tasks, jobs, incidents and
-deployments. The team built the process models and scenarios on top of it.
+I built the Camunda 8 client layer the platform uses for processes, messages,
+user tasks, incidents and deployments, and the user task framework: the handler
+pipeline, the worklist, the task stepper and the form renderer. I led the team
+that built the process models, the scenarios and the task pool on top of them.
diff --git a/content/work/order-platform-foundation.mdx b/content/work/order-platform-foundation.mdx
deleted file mode 100644
index 5414c59..0000000
--- a/content/work/order-platform-foundation.mdx
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: "A foundation a whole team builds on"
-summary: "The service template, shared building blocks, gateway and one-command local environment that every module of a telco order platform starts from."
-sector: "Telco"
-role: "Lead Developer"
-themes: ["architecture-integration", "delivery-operations"]
-kind: "client"
-programme: "telco-service-orchestration"
-period: "2024 — now"
-date: "2024-10-02"
-stack: [".NET", "ASP.NET Core", ".NET Aspire", "YARP", "Kafka", "Serilog", "PostgreSQL", "Docker"]
----
-
-## Context
-
-A legacy ordering platform was being replaced by .NET microservices, with a team
-that would grow past ten engineers. Before the first feature, every module
-needed the same answers: how a service is laid out, how it logs, caches, calls
-other systems and runs background work, how requests reach it, and how a
-developer runs everything on a laptop.
-
-
-
-
-
-
-
-
-## The decisions
-
-- **One layout for every service.** A developer moving between modules already
- knows where everything lives.
-- **Logs go to Kafka first,** then to the database in batches, so logging never
- slows a request down.
-- **Cache invalidation is an event.** A service that changes cached data
- publishes it, and every pod clears its copy. Scaling out never serves stale
- data.
-- **The gateway stays thin.** It routes by module and does nothing else;
- authentication stays where it already was during the transition, so the new
- platform could grow without first rebuilding security.
-- **One command for the whole system.** An Aspire app host brings up Kafka,
- PostgreSQL, the legacy Oracle database, the workflow engine, a mock server for
- the downstream systems, the UI and every module, with profiles per product and
- environment.
-
-## Outcome
-
-A new module starts from a working skeleton, and a new developer runs the full
-system locally on day one. I set up the foundation; the team has extended it
-since.
diff --git a/content/work/product-catalog.mdx b/content/work/product-catalog.mdx
new file mode 100644
index 0000000..10ac9dd
--- /dev/null
+++ b/content/work/product-catalog.mdx
@@ -0,0 +1,57 @@
+---
+title: "A product catalog on TM Forum's model"
+summary: "What can be sold, how it is priced and when it goes on sale is defined in one catalog aligned with TM Forum, with a lifecycle from design to retirement."
+sector: "Telco"
+role: "Lead Developer"
+themes: ["domain-modeling-rules", "architecture-integration"]
+kind: "client"
+programme: "telco-service-orchestration"
+period: "2025 — now"
+date: "2025-09-01"
+stack: [".NET", "ASP.NET Core", "EF Core", "PostgreSQL", "Vue 3"]
+---
+
+## Context
+
+Every quote starts from the catalog. It decides what can be sold, with which
+options, at what price and under which terms. In telecom it is also the part
+that changes most often: new speeds, new bundles, new discounts. If those live
+in code, every commercial change waits for a release.
+
+## How it is modeled
+
+We followed TM Forum's product and service catalog model (TMF620, TMF633,
+TMF634), so the catalog speaks the same language as the rest of the industry.
+
+
+
+
+
+
+
+
+Nothing goes on sale half-finished. Every catalog item moves through the same
+lifecycle, and the allowed moves between states are kept in one map. Changing
+the flow means changing that map, not the services that use it.
+
+
+
+## What it gives the business
+
+- Options, prices, discounts and validity dates are data, maintained from the
+ catalog screens.
+- The lifecycle keeps unfinished items from going live.
+- The TM Forum model makes the catalog easier to connect to other systems,
+ because the terms are shared.
+
+A new kind of product can still need new logic when the order is split into
+its parts. The catalog covers what changes most often, and that is where the
+time was going.
+
+## My part
+
+I led the team that built it and contributed to the catalog module.
diff --git a/content/work/telco-service-orchestration.mdx b/content/work/telco-service-orchestration.mdx
index d05d090..65ea927 100644
--- a/content/work/telco-service-orchestration.mdx
+++ b/content/work/telco-service-orchestration.mdx
@@ -1,13 +1,13 @@
---
-title: "Order management transformation in the telco domain"
-summary: "A legacy B2B ordering stack rebuilt as .NET microservices, one service line at a time, with both systems running side by side and live orders never disrupted."
+title: "Replacing a telco's order management while it keeps taking orders"
+summary: "I lead the teams replacing a legacy B2B ordering system with .NET microservices, one service line at a time, while the old system keeps running."
sector: "Telco"
role: "Lead Developer"
themes: ["legacy-modernization", "architecture-integration"]
kind: "client"
period: "2024 — now"
date: "2026-09-01"
-stack: [".NET", "ASP.NET Core", ".NET Aspire", "Camunda", "Kafka", "PostgreSQL", "Vue 3", "OpenShift", "Conceptwave (legacy)"]
+stack: [".NET", "ASP.NET Core", ".NET Aspire", "Camunda 8", "Kafka", "PostgreSQL", "Vue 3", "OpenShift", "Conceptwave (legacy)"]
outcomes:
- { value: "2", label: "teams led, new platform and legacy", countTo: 2 }
- { value: "10+", label: "engineers", countTo: 10 }
@@ -18,57 +18,60 @@ featured: true
## Context
-A telecom operator runs its B2B ordering on a legacy Conceptwave-based stack.
-The order flow crosses many downstream systems, change windows are regulated,
-and the business can't stop taking orders while the platform underneath it is
-replaced. The move happens one service line at a time, over several years,
-until Conceptwave can be retired.
+A telecom operator takes its business orders on a legacy Conceptwave system.
+An order crosses many downstream systems, change windows are regulated, and
+the business can't stop selling while the platform under it is replaced. So
+the move happens one service line at a time, over several years, until the old
+system can be switched off.
-I lead both teams: the transformation team building the new platform, and the
-Conceptwave team that keeps the legacy system running through the transition.
+I lead both teams: the one building the new platform, and the one keeping the
+legacy system running until then.
## The path of an order
-The new platform covers the full order flow, modeled on TM Forum Open APIs and
-integrated with the operator's downstream systems.
+The new platform covers the whole flow, modeled on TM Forum's Open APIs.
+## The platform
-## What I built
-
-**The foundation.** I set up the platform the team builds on: the repository
-and the structure of every service, the implementation templates, the shared
-building blocks for logging, caching, migrations and API clients, the API
-gateway, and the .NET Aspire environment the whole team develops and runs the
-system in.
-
-**The modules on top of it.** I contribute across all of them: order
-management (quote, decomposition into product orders, discounts), the order
-entry UI and the task framework its screens run on, the product catalog and
-the utility services.
-
-## Decisions
-
-**Build on reusable assets.** Catalog, ordering, workflow and integration
-components are shared, so each new service line builds on the same foundation
-instead of starting over.
-
-**Move in phases, side by side.** Each service line is cut over on its own.
-Both systems run in parallel, and the new platform has to show it behaves like
-the old one before the switch, inside the regulated change window.
+
-**One way of working for both teams.** Implementation templates, code review,
-unit testing and quality standards are the same on the new platform and on the
-legacy side, and I mentor the developers on both teams.
+## What I built myself
+
+- **The foundation.** The repository, the layout every service follows, the
+ shared library for logging, cache invalidation and background jobs, the API
+ gateway, and the .NET Aspire setup that runs the whole system on a laptop
+ with one command.
+- **Logging that doesn't slow requests down.** Logs go to Kafka and are written
+ to the database in batches.
+- **Cache invalidation as an event.** When a service changes cached data, every
+ pod drops its copy.
+- **A thin gateway.** It routes to modules and nothing else. Authentication
+ stayed where it was during the transition, so we didn't have to rebuild
+ security before shipping anything.
+- **The Camunda 8 client layer** the platform uses for processes, messages,
+ user tasks, incidents and deployments.
+- **The user task framework**: one pipeline and one form renderer for hundreds
+ of human steps.
+
+## How we work
+
+Both teams follow the same templates, code review, unit testing and quality
+standards, on the new platform and on the legacy side. I review the work and
+mentor the developers on both teams.
## Outcome
-Cut-overs ship on schedule without disrupting live order flows. Each new
-service line starts from the shared assets rather than from scratch, and the
-legacy system stays stable for the business until its last service line moves
-over.
+Each service line moves on its own, with both systems running side by side
+until it does. Cut-overs have shipped on schedule without disrupting live
+orders, and every new service line starts from the same foundation instead of
+from scratch.
diff --git a/src/app/work/page.tsx b/src/app/work/page.tsx
index 4e3df10..1451d9b 100644
--- a/src/app/work/page.tsx
+++ b/src/app/work/page.tsx
@@ -21,12 +21,12 @@ export async function generateMetadata(): Promise {
export default async function WorkPage() {
const t = await getTranslations("work");
const work = await getAllWork();
- // Featured cases lead the page; every other case is listed once, under its
- // first theme. Empty themes are hidden.
+ // Featured cases lead the page; every case is also listed under its first
+ // theme, so no practice area looks empty. Empty themes are hidden.
const featured = work.filter((w) => w.featured);
const sections = THEMES.map((theme) => ({
...theme,
- items: work.filter((w) => !w.featured && w.themes[0] === theme.slug),
+ items: work.filter((w) => w.themes[0] === theme.slug),
})).filter((s) => s.items.length > 0);
return (
diff --git a/src/components/diagram/blocks.tsx b/src/components/diagram/blocks.tsx
index a778a86..e0e94f9 100644
--- a/src/components/diagram/blocks.tsx
+++ b/src/components/diagram/blocks.tsx
@@ -138,3 +138,83 @@ export function Timeline({ items }: { items: string }) {
);
}
+
+/** A system at a glance: columns left to right (top to bottom on phones),
+ * each "Title: item; item; item". Items starting with "*" are highlighted,
+ * and `legend` says what the highlight means.
+ * */
+export function SystemMap({
+ title,
+ columns,
+ legend,
+}: {
+ title?: string;
+ columns: string;
+ legend?: string;
+}) {
+ const cols = split(columns).map((col) => {
+ const [head, ...rest] = col.split(":");
+ const items = rest
+ .join(":")
+ .split(";")
+ .map((s) => s.trim())
+ .filter(Boolean)
+ .map((s) =>
+ s.startsWith("*")
+ ? { label: s.slice(1).trim(), hot: true }
+ : { label: s, hot: false },
+ );
+ return { head: head.trim(), items };
+ });
+ return (
+
+
+ {cols.map((col, i) => (
+
+ {i > 0 && (
+
+ ↓
+ →
+
+ )}
+
+
+ {col.head}
+
+ {col.items.map((item) => (
+
+ {item.label}
+
+ ))}
+
+
+ ))}
+
+ {(title || legend) && (
+
+ {title}
+ {legend && (
+
+
+ {legend}
+
+ )}
+
+ )}
+
+ );
+}
diff --git a/src/components/writings/mdx-components.tsx b/src/components/writings/mdx-components.tsx
index c01104f..d4a0d8d 100644
--- a/src/components/writings/mdx-components.tsx
+++ b/src/components/writings/mdx-components.tsx
@@ -3,7 +3,12 @@ import type { MDXComponents } from "mdx/types";
import { CopyButton } from "./copy-button";
import { Callout, Figure, Layer, LayerStack, PullQuote } from "./mdx-blocks";
import { Flow } from "@/components/diagram/flow";
-import { Compare, Matrix, Timeline } from "@/components/diagram/blocks";
+import {
+ Compare,
+ Matrix,
+ Timeline,
+ SystemMap,
+} from "@/components/diagram/blocks";
import { Demo } from "@/components/labs/demo";
/** Styled elements for rendered MDX articles. Code blocks are highlighted by
@@ -98,5 +103,6 @@ export const mdxComponents: MDXComponents = {
Compare,
Matrix,
Timeline,
+ SystemMap,
Demo,
};
diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json
index 4d03c6d..ca86399 100644
--- a/src/i18n/messages/en.json
+++ b/src/i18n/messages/en.json
@@ -25,7 +25,7 @@
"orchestration that carries real load",
"test strategy that holds"
],
- "subtitle": "Architecture, workflow orchestration and test strategy for platforms that carry real load — and AI that works inside the guardrails, not around them: spec-driven generation, deterministic gates, evidence over promises.",
+ "subtitle": "I design and build enterprise systems on .NET: order management, workflow orchestration and integration. And I work on how a team can use AI in delivery while people still decide what reaches production.",
"ctaWork": "See the work",
"ctaWritings": "Read the writing",
"signature": "AI produces · people decide · the engine verifies. Goldpath lays the path, SpecDrift keeps it honest.",
@@ -39,31 +39,43 @@
"Every business event carries its rule id, so the running system explains itself."
],
"practiceTitle": "Practice",
- "practiceIntro": "Four things I do, each with something you can open.",
+ "practiceIntro": "Six areas I work in, each with something you can open.",
"practice": [
{
- "title": "Architecture & platforms",
- "desc": "Service boundaries, shared building blocks and reusable assets, so each new product line builds on the same foundation.",
+ "title": "Architecture & integration",
+ "desc": "Service boundaries, shared foundations, gateways and the contracts between systems.",
"href": "/work/telco-service-orchestration",
- "proof": "order management platform"
+ "proof": "order platform"
},
{
"title": "Workflow orchestration",
- "desc": "A Camunda process per order, asynchronous callbacks from downstream systems, and phased cut-overs for order flows that carry real load.",
- "href": "/labs/workflow-stepper",
- "proof": "workflow stepper"
+ "desc": "One process per order, late answers from downstream systems, and the people in between.",
+ "href": "/work/order-orchestration",
+ "proof": "process per order"
},
{
- "title": "Test strategy & quality",
- "desc": "Unit, contract and end-to-end tests, mocks that can't lie, and a strategy strong enough to decide what reaches production.",
+ "title": "Domain modeling & rules",
+ "desc": "A catalog on TM Forum's model, and business rules kept as data.",
+ "href": "/work/business-rules",
+ "proof": "rules as data"
+ },
+ {
+ "title": "Legacy modernization",
+ "desc": "Replacing a live system one service line at a time while it keeps taking orders.",
+ "href": "/work/telco-service-orchestration",
+ "proof": "order management"
+ },
+ {
+ "title": "Quality & test strategy",
+ "desc": "Tests strong enough to decide what reaches production.",
"href": "/labs/test-pyramid",
"proof": "test pyramid"
},
{
- "title": "AI inside the guardrails",
- "desc": "Specifications, architecture rules and deterministic checks that keep AI-written code honest. People own the decisions.",
- "href": "/labs/spec-drift",
- "proof": "spec drift"
+ "title": "Delivery & operations",
+ "desc": "From first commit to production and keeping it running, with AI doing the typing and written rules deciding what is done.",
+ "href": "/work/internal-learning-platform",
+ "proof": "internal platform"
}
],
"workTitle": "Work",