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",