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
152 changes: 120 additions & 32 deletions content/labs/workflow-stepper/Demo.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -2,70 +2,158 @@

import { useState } from "react";

const STEPS = [
{ task: "Validate order", event: "order.received", system: "API" },
{ task: "Reserve resources", event: "inventory.reserved", system: "Inventory" },
{ task: "Provision service", event: "service.provisioned", system: "Network" },
{ task: "Activate & bill", event: "service.activated", system: "Billing" },
type Actor = "person" | "system" | "engine" | "downstream";

type Step = {
task: string;
actor: Actor;
/** What completes the step, as the button reads while it is current. */
action: string;
events: string[];
};

/** A generic order, end to end: the shape of the flow, none of a client's names. */
const STEPS: Step[] = [
{ task: "Quote submitted", actor: "person", action: "Submit quote", events: ["quote.submitted"] },
{
task: "Decomposed into product orders",
actor: "system",
action: "Decompose",
events: ["product-order.created #1", "product-order.created #2"],
},
{ task: "One process per product order", actor: "engine", action: "Start process", events: ["process.started #1"] },
{ task: "Service order created", actor: "engine", action: "Create service order", events: ["service-order.created"] },
{ task: "Reserve network resources", actor: "downstream", action: "Receive callback", events: ["callback resource.reserved"] },
{ task: "Confirm technical details", actor: "person", action: "Complete task", events: ["task.completed"] },
{ task: "Activate and start billing", actor: "downstream", action: "Receive callback", events: ["callback billing.started"] },
{ task: "Product order completed", actor: "engine", action: "Complete", events: ["product-order.completed #1"] },
];

/** Placeholder demo: a process with its emitted events. */
/** From this step on, the order can no longer be cancelled. */
const MILESTONE = 6;

const ACTOR_LABEL: Record<Actor, string> = {
person: "people",
system: "system",
engine: "engine",
downstream: "callback",
};

type LogLine = { event: string; tone?: "reject" | "stop" };

/** One product order stepped through its process, with the events it emits
* and a cancellation that only holds before the point of no return. */
export default function WorkflowStepperDemo() {
const [step, setStep] = useState(0);
const [log, setLog] = useState<LogLine[]>([]);
const [cancelled, setCancelled] = useState(false);

const done = step >= STEPS.length;
const stopped = done || cancelled;
const current = STEPS[step];

function advance() {
if (stopped) return;
setLog((l) => [...l, ...current.events.map((event) => ({ event }))]);
setStep((s) => s + 1);
}

function cancel() {
if (stopped) return;
if (step < MILESTONE) {
setCancelled(true);
setLog((l) => [
...l,
{ event: "cancel.requested" },
{ event: "product-order.cancelled #1", tone: "stop" },
]);
} else {
setLog((l) => [...l, { event: "cancel.rejected · past milestone", tone: "reject" }]);
}
}

function reset() {
setStep(0);
setLog([]);
setCancelled(false);
}

return (
<div className="grid gap-0 sm:grid-cols-[1fr_1fr]">
<div className="p-4">
<p className="mono mb-3 text-caption text-faint">process · order #4821</p>
<ol className="flex flex-col gap-2">
<p className="mono mb-3 text-caption text-faint">product order #1 · its process</p>
<ol className="flex flex-col gap-1.5">
{STEPS.map((s, i) => {
const state = i < step ? "done" : i === step ? "current" : "todo";
const state =
i < step ? "done" : i === step && !stopped ? "current" : "todo";
return (
<li
key={s.task}
className={`flex items-center justify-between gap-3 rounded-[var(--radius-md)] border px-3 py-2 text-ui ${
state === "current"
? "border-brand-accent text-foreground"
: state === "done"
? "border-foreground text-foreground"
: "border-border text-muted-foreground"
}`}
>
<span>{s.task}</span>
<span className="mono text-caption text-muted-foreground">{s.system}</span>
<li key={s.task}>
{i === MILESTONE && (
<p className="mono my-1 text-caption text-faint">— milestone: no cancel after this —</p>
)}
<div
className={`flex items-center justify-between gap-3 rounded-[var(--radius-md)] border px-3 py-1.5 text-ui ${
state === "current"
? "border-brand-accent text-foreground"
: state === "done"
? "border-foreground text-foreground"
: "border-border text-muted-foreground"
} ${cancelled && i >= step ? "line-through" : ""}`}
>
<span>{s.task}</span>
<span className="mono shrink-0 text-caption text-muted-foreground">
{ACTOR_LABEL[s.actor]}
</span>
</div>
</li>
);
})}
</ol>
<div className="mt-3 flex gap-2">
<div className="mt-3 flex flex-wrap gap-2">
<button
type="button"
onClick={() => setStep((s) => Math.min(STEPS.length, s + 1))}
disabled={done}
onClick={advance}
disabled={stopped}
className="h-8 rounded-[var(--radius-md)] border border-border px-3 text-ui font-medium text-foreground transition-colors hover:border-foreground disabled:opacity-50"
>
{done ? "Completed" : "Complete step"}
{cancelled ? "Cancelled" : done ? "Completed" : current.action}
</button>
<button
type="button"
onClick={cancel}
disabled={stopped || step === 0}
className="h-8 rounded-[var(--radius-md)] border border-border px-3 text-ui text-muted-foreground transition-colors hover:border-foreground hover:text-foreground disabled:opacity-50"
>
Cancel while running
</button>
<button
type="button"
onClick={() => setStep(0)}
onClick={reset}
className="h-8 rounded-[var(--radius-md)] border border-border px-3 text-ui text-muted-foreground transition-colors hover:border-foreground hover:text-foreground"
>
Reset
</button>
</div>
</div>
<div className="border-t border-border p-4 sm:border-s sm:border-t-0">
<p className="mono mb-3 text-caption text-faint">events on the log</p>
<p className="mono mb-3 text-caption text-faint">events, in order</p>
<div className="mono flex flex-col gap-1.5 text-caption">
{STEPS.slice(0, step).map((s, i) => (
<p key={s.event} className="flex justify-between gap-3 text-foreground">
<span>{s.event}</span>
<span className="text-muted-foreground">t+{(i + 1) * 120}ms</span>
{log.map((line, i) => (
<p
key={`${line.event}-${i}`}
className={`flex justify-between gap-3 ${
line.tone === "reject"
? "text-muted-foreground"
: line.tone === "stop"
? "text-brand-accent"
: "text-foreground"
}`}
>
<span>{line.event}</span>
<span className="text-muted-foreground">{String(i + 1).padStart(2, "0")}</span>
</p>
))}
{step === 0 && <p className="text-muted-foreground">nothing yet — complete a step</p>}
{log.length === 0 && <p className="text-muted-foreground">nothing yet — submit the quote</p>}
</div>
</div>
</div>
Expand Down
20 changes: 13 additions & 7 deletions content/labs/workflow-stepper/lab.mdx
Original file line number Diff line number Diff line change
@@ -1,15 +1,21 @@
---
title: "Workflow stepper"
summary: "Step through an orchestrated service process and watch the events it emits."
summary: "Step one product order through its process, watch the events it emits, and try to cancel it midway."
date: "2026-09-17"
topic: "orchestration"
preview: "process"
tags: ["camunda", "kafka", "orchestration"]
tags: ["camunda", "orchestration", "order management"]
---

A service order in the telco domain touches many systems. Modelling the
process as a first-class artifact — BPMN in an engine, events on a log —
means every step has a name, a state and a trace. The stepper shows what a
single order looks like from the process's point of view.
A submitted quote doesn't become one big transaction. It is decomposed into
product orders, and each product order runs as its own Camunda process. The
process creates the service orders that deliver the product, then waits:
downstream systems answer asynchronously through callbacks, and the steps that
need a person become user tasks.

Placeholder: the real demo will replay an anonymised process definition.
Modelling it this way means every order has a name, a state and a history,
and a question like "can this still be cancelled?" has a precise answer. Before
the milestone, a cancel request stops the process cleanly. After it, the
request is rejected, because work downstream can no longer be taken back.

The flow is generic: the shape of a real order platform, none of its names.
23 changes: 17 additions & 6 deletions content/work/telco-service-orchestration.mdx
Original file line number Diff line number Diff line change
Expand Up @@ -5,7 +5,7 @@ sector: "Telco"
role: "Lead Developer"
period: "2024 — now"
date: "2026-09-01"
stack: [".NET", "ASP.NET Core", "Camunda", "Kafka", "PostgreSQL", "Vue 3", "OpenShift", "Conceptwave (legacy)"]
stack: [".NET", "ASP.NET Core", ".NET Aspire", "Camunda", "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 }
Expand All @@ -32,19 +32,30 @@ integrated with the operator's downstream systems.

<Flow
title="An order, end to end"
steps="Catalog: product offerings | Quote: priced, validated | Product order: submitted | Decompose: into service orders | Fulfil: Camunda workflows and user tasks | Integrate: Kafka and REST to downstream systems"
notes="The product catalog defines what can be sold, aligned with TM Forum. | A quote is built from the catalog and validated before it becomes an order. | The product order is the commitment to the customer. | Each product order is decomposed into the service orders that deliver it. | Camunda runs each service order; people complete their steps as user tasks. | Every hop to a downstream system is an event or a contract, traced end to end."
steps="Catalog: product offerings | Quote: priced, validated, submitted | Product orders: decomposed from the quote | Process: one Camunda process per order | Service orders: created by the process | Fulfil: downstream callbacks and user tasks"
notes="The product catalog defines what can be sold, aligned with TM Forum. | A quote is built from the catalog and validated; submitting it is the commitment to the customer. | The submitted quote is decomposed into product orders, one per product being delivered. | Each product order runs as its own Camunda process, so every order has a state, a history and a trace. | The process creates the service orders that deliver the product and waits for them. | Downstream systems answer asynchronously through callbacks; the steps that need a person become user tasks."
/>

<Demo id="workflow-stepper" />

## 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. I wrote much of that foundation myself: the API
gateway, the building blocks for logging, caching and API clients, the Camunda
integration and the task framework the order screens run on.
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
Expand Down
Binary file modified public/cv.pdf
Binary file not shown.
2 changes: 1 addition & 1 deletion src/config/profile.ts
Original file line number Diff line number Diff line change
Expand Up @@ -49,7 +49,7 @@ export const profile = {
org: "DefineX",
context: "Consulting, Technology & Labs",
summary:
"Leading a large, multi-year order management transformation for a telecom operator: a legacy Conceptwave-based B2B ordering stack replaced with .NET microservices, one service line at a time. I lead both teams, 10+ engineers in total, own the technical design from the Vue.js interface and API gateway to the ASP.NET Core services, Camunda workflows and Kafka integration, and build much of the foundation myself. Cut-overs ship on schedule without disrupting live order flows.",
"Leading a large, multi-year order management transformation for a telecom operator: a legacy Conceptwave-based B2B ordering stack replaced with .NET microservices, one service line at a time. I lead both teams, 10+ engineers in total, and own the technical design from the Vue.js interface and API gateway to the ASP.NET Core services, Camunda workflows and Kafka messaging. I set up the platform's foundation, from the structure of every service and the implementation templates to the shared building blocks and the .NET Aspire environment the team develops in, and contribute across all of its modules. Cut-overs ship on schedule without disrupting live order flows.",
},
{
from: "2021",
Expand Down
2 changes: 1 addition & 1 deletion src/i18n/messages/en.json
Original file line number Diff line number Diff line change
Expand Up @@ -49,7 +49,7 @@
},
{
"title": "Workflow orchestration",
"desc": "Camunda, Kafka and phased cut-overs for order processes that carry real load.",
"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"
},
Expand Down
Loading