diff --git a/content/work/generic-user-tasks.mdx b/content/work/generic-user-tasks.mdx new file mode 100644 index 0000000..20fd169 --- /dev/null +++ b/content/work/generic-user-tasks.mdx @@ -0,0 +1,40 @@ +--- +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 new file mode 100644 index 0000000..076233f --- /dev/null +++ b/content/work/internal-learning-platform.mdx @@ -0,0 +1,73 @@ +--- +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." +sector: "Corporate learning" +role: "Founder & engineering lead" +themes: ["delivery-operations", "quality-test-strategy"] +kind: "internal" +aiNative: true +period: "2026 — now" +date: "2026-04-06" +stack: [".NET 10", "ASP.NET Core", "EF Core", "PostgreSQL", "Quartz", "Next.js", "React", "Entra ID", "GitLab CI", "Docker", "nginx", "Playwright"] +outcomes: + - { value: "3", label: "months to production", countTo: 3 } + - { value: "400", label: "people using it", countTo: 400 } + - { value: "2000+", label: "automated tests", countTo: 2000 } +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 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. + + + + + +## Proof before go-live + +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. + +## 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. diff --git a/content/work/order-orchestration.mdx b/content/work/order-orchestration.mdx new file mode 100644 index 0000000..31921a5 --- /dev/null +++ b/content/work/order-orchestration.mdx @@ -0,0 +1,42 @@ +--- +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." +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"] +--- + +## 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?". + + + +## 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. + +## 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. diff --git a/content/work/order-platform-foundation.mdx b/content/work/order-platform-foundation.mdx new file mode 100644 index 0000000..5414c59 --- /dev/null +++ b/content/work/order-platform-foundation.mdx @@ -0,0 +1,50 @@ +--- +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/telco-service-orchestration.mdx b/content/work/telco-service-orchestration.mdx index ea4a1b5..d05d090 100644 --- a/content/work/telco-service-orchestration.mdx +++ b/content/work/telco-service-orchestration.mdx @@ -3,6 +3,8 @@ 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." 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)"] @@ -36,7 +38,6 @@ integrated with the operator's downstream systems. 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." /> - ## What I built diff --git a/src/app/work/[slug]/page.tsx b/src/app/work/[slug]/page.tsx index ea1b9b6..8739fbd 100644 --- a/src/app/work/[slug]/page.tsx +++ b/src/app/work/[slug]/page.tsx @@ -4,14 +4,16 @@ import { notFound } from "next/navigation"; import { getTranslations } from "next-intl/server"; import { ArrowLeft } from "lucide-react"; import { RailSection, ReadingShell } from "@/components/layout/reading-shell"; -import { Tag } from "@/components/ui/badge"; +import { Label, Tag } from "@/components/ui/badge"; +import { WorkCard } from "@/components/work/work-card"; +import { getTheme } from "@/config/themes"; import { Counter } from "@/components/motion/counter"; import { LabCard } from "@/components/labs/lab-card"; import { Toc } from "@/components/writings/toc"; import { renderMdx } from "@/lib/mdx"; import { extractHeadings } from "@/lib/writings"; import { getLabsBySlugs } from "@/lib/labs"; -import { getWorkBySlug, getWorkSlugs } from "@/lib/work"; +import { getProgrammeParts, getWorkBySlug, getWorkSlugs } from "@/lib/work"; import { pageMetadata } from "@/lib/seo"; export async function generateStaticParams() { @@ -45,10 +47,13 @@ export default async function WorkStudyPage({ const work = await getWorkBySlug(slug); if (!work) notFound(); - const [content, labs] = await Promise.all([ + const [content, labs, parts, programme] = await Promise.all([ renderMdx(work.content), getLabsBySlugs(work.labs ?? []), + getProgrammeParts(work.slug), + work.programme ? getWorkBySlug(work.programme) : null, ]); + const themes = work.themes.map(getTheme).filter((x) => x !== undefined); const headings = extractHeadings(work.content); return ( @@ -57,8 +62,25 @@ export default async function WorkStudyPage({ <>
{work.sector} + {t(`kinds.${work.kind}`)} {work.role} {work.period} +
+
+ {t("themes")} +
+
+ {themes.map((theme) => ( + + {theme.title} + + ))} +
+
{t("stack")} @@ -87,9 +109,23 @@ export default async function WorkStudyPage({
-

- {work.sector} · {work.period} +

+ + {work.sector} · {t(`kinds.${work.kind}`)} · {work.period} + + {work.aiNative && }

+ {programme && ( +

+ {t("partOf")}{" "} + + {programme.title} + +

+ )}

{work.title}

{work.summary}

{work.outcomes && work.outcomes.length > 0 && ( @@ -117,6 +153,17 @@ export default async function WorkStudyPage({
{content}
+ {parts.length > 0 && ( +
+

{t("parts")}

+
+ {parts.map((part) => ( + + ))} +
+
+ )} + {labs.length > 0 && (

{t("tryIt")}

diff --git a/src/app/work/page.tsx b/src/app/work/page.tsx index 5739d1f..4e3df10 100644 --- a/src/app/work/page.tsx +++ b/src/app/work/page.tsx @@ -6,6 +6,7 @@ import { WorkCard } from "@/components/work/work-card"; import { QorpeBand } from "@/components/home/qorpe-band"; import { OpenSource } from "@/components/products/open-source"; import { getAllWork } from "@/lib/work"; +import { THEMES } from "@/config/themes"; import { pageMetadata } from "@/lib/seo"; export async function generateMetadata(): Promise { @@ -20,6 +21,13 @@ 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. + const featured = work.filter((w) => w.featured); + const sections = THEMES.map((theme) => ({ + ...theme, + items: work.filter((w) => !w.featured && w.themes[0] === theme.slug), + })).filter((s) => s.items.length > 0); return ( @@ -29,9 +37,40 @@ export default async function WorkPage() { {t("empty")}

) : ( -
- {work.map((item) => ( - +
+ {featured.length > 0 && ( +
+
+ {featured.map((item) => ( + + ))} +
+
+ )} + {sections.map((section) => ( +
+
+

+ {section.title} +

+

+ {section.summary} +

+
+
+ {section.items.map((item) => ( + + ))} +
+
))}
)} diff --git a/src/components/work/work-card.tsx b/src/components/work/work-card.tsx index 467a05b..ec25ede 100644 --- a/src/components/work/work-card.tsx +++ b/src/components/work/work-card.tsx @@ -1,11 +1,14 @@ import Link from "next/link"; +import { useTranslations } from "next-intl"; import { ArrowUpRight } from "lucide-react"; import { Counter } from "@/components/motion/counter"; +import { Label } from "@/components/ui/badge"; import type { WorkMeta } from "@/lib/work"; -/** A case study in a list: sector and period, title, one line, outcome +/** A case study in a list: sector, kind and period, title, one line, outcome * tiles. Only colour changes on hover. */ export function WorkCard({ work }: { work: WorkMeta }) { + const t = useTranslations("work"); return ( - - {work.sector} · {work.period} + + + {work.sector} · {t(`kinds.${work.kind}`)} · {work.period} + + {work.aiNative && } {work.title} diff --git a/src/config/themes.ts b/src/config/themes.ts new file mode 100644 index 0000000..cc6c69d --- /dev/null +++ b/src/config/themes.ts @@ -0,0 +1,51 @@ +/** The practice areas the site is organised by. Work, and later writing and + * labs, are grouped under these; employers and clients never are. A case + * lists one or two themes, the first being where it is shown. + * + * Order here is the display order. Slugs are part of URLs and anchors, so + * treat them as permanent. + */ +export const THEMES = [ + { + slug: "architecture-integration", + title: "Architecture & integration", + summary: + "Service boundaries, platform foundations, gateways and the contracts between systems.", + }, + { + slug: "workflow-orchestration", + title: "Workflow orchestration", + summary: + "Long-running processes, asynchronous callbacks, human tasks and bulk operations.", + }, + { + slug: "domain-modeling-rules", + title: "Domain modeling & rules", + summary: "Catalogs, industry standards and business rule engines.", + }, + { + slug: "legacy-modernization", + title: "Legacy modernization", + summary: + "Running old and new side by side, keeping data in step, and cutting over in phases.", + }, + { + slug: "quality-test-strategy", + title: "Quality & test strategy", + summary: "Test strategy strong enough to decide what reaches production.", + }, + { + slug: "delivery-operations", + title: "Delivery & operations", + summary: + "CI/CD, environments, logging, backups and running what was built.", + }, +] as const; + +export type ThemeSlug = (typeof THEMES)[number]["slug"]; + +export const THEME_SLUGS: readonly string[] = THEMES.map((t) => t.slug); + +export function getTheme(slug: string) { + return THEMES.find((t) => t.slug === slug); +} diff --git a/src/i18n/messages/en.json b/src/i18n/messages/en.json index 7a32028..4d03c6d 100644 --- a/src/i18n/messages/en.json +++ b/src/i18n/messages/en.json @@ -78,7 +78,7 @@ }, "work": { "title": "Work", - "subtitle": "Case studies from platforms that carry real load: what the situation was, what I decided, what came of it. Client names withheld; domains kept.", + "subtitle": "Case studies grouped by practice area: what the situation was, what I decided, what came of it. Client names withheld; domains kept.", "empty": "Nothing to show here yet.", "backToList": "All work", "tryIt": "Try it", @@ -86,7 +86,19 @@ "role": "Role", "period": "Period", "stack": "Stack", - "onThisPage": "On this page" + "onThisPage": "On this page", + "kind": "Type", + "kinds": { + "client": "Client", + "internal": "Internal platform", + "open-source": "Open source", + "solution-design": "Solution design" + }, + "aiNative": "AI-native", + "themes": "Practice areas", + "partOf": "Part of", + "parts": "The parts", + "featured": "Featured work" }, "labs": { "title": "Labs", diff --git a/src/lib/work.test.ts b/src/lib/work.test.ts index 1a8f668..8bb3f18 100644 --- a/src/lib/work.test.ts +++ b/src/lib/work.test.ts @@ -1,6 +1,8 @@ import { describe, expect, it } from "vitest"; import { getAllWork } from "./work"; import { getAllLabs } from "./labs"; +import { THEME_SLUGS } from "@/config/themes"; +import { WORK_KINDS } from "./work"; describe("work", () => { it("every case study has the card fields and only known labs", async () => { @@ -16,4 +18,30 @@ describe("work", () => { for (const lab of w.labs ?? []) expect(known.has(lab)).toBe(true); } }); + + it("files every case under one or two known themes, with a known kind", async () => { + for (const w of await getAllWork()) { + expect(w.themes.length, w.slug).toBeGreaterThanOrEqual(1); + expect(w.themes.length, w.slug).toBeLessThanOrEqual(2); + for (const t of w.themes) expect(THEME_SLUGS, w.slug).toContain(t); + expect(WORK_KINDS, w.slug).toContain(w.kind); + } + }); + + it("never marks client work as AI-native", async () => { + for (const w of await getAllWork()) { + if (w.kind === "client") expect(w.aiNative, w.slug).toBe(false); + } + }); + + it("points every part at an existing overview", async () => { + const work = await getAllWork(); + const slugs = new Set(work.map((w) => w.slug)); + for (const w of work) { + if (w.programme) { + expect(slugs.has(w.programme), w.slug).toBe(true); + expect(w.programme, w.slug).not.toBe(w.slug); + } + } + }); }); diff --git a/src/lib/work.ts b/src/lib/work.ts index 3884ae3..bc1eac9 100644 --- a/src/lib/work.ts +++ b/src/lib/work.ts @@ -6,9 +6,21 @@ import { newestFirst, readMdx, } from "./content"; +import type { ThemeSlug } from "@/config/themes"; const WORK_DIR = path.join(CONTENT_DIR, "work"); +/** What kind of work a case is. Only the kind is shown, never the employer. */ +export type WorkKind = + "client" | "internal" | "open-source" | "solution-design"; + +export const WORK_KINDS: readonly WorkKind[] = [ + "client", + "internal", + "open-source", + "solution-design", +]; + /** A case study: content/work/.mdx. The frontmatter is the card; the * body is the story (context → decision → outcome). */ export interface WorkFrontmatter { @@ -18,6 +30,13 @@ export interface WorkFrontmatter { /** Domain, never a client name ("Telco", "Banking"). */ sector: string; role: string; + /** One or two practice areas; the first decides where the case is listed. */ + themes: ThemeSlug[]; + kind: WorkKind; + /** Slug of the overview case this one is a part of, if any. */ + programme?: string; + /** Built AI-natively. Never set on client work. */ + aiNative?: boolean; /** "2024 — now", "2022 — 2023". */ period: string; date: string; @@ -49,6 +68,8 @@ async function readAll(): Promise { stack: parsed.data.stack ?? [], outcomes: parsed.data.outcomes ?? [], labs: parsed.data.labs ?? [], + themes: parsed.data.themes ?? [], + aiNative: parsed.data.aiNative ?? false, featured: parsed.data.featured ?? false, draft: parsed.data.draft ?? false, slug: file.replace(/\.mdx?$/, ""), @@ -77,6 +98,13 @@ export async function getWorkBySlug(slug: string): Promise { return (await readAll()).find((w) => w.slug === slug) ?? null; } +/** The parts of an overview case, in their listed order (oldest first). */ +export async function getProgrammeParts(slug: string): Promise { + return (await getAllWork()) + .filter((w) => w.programme === slug) + .sort((a, b) => a.date.localeCompare(b.date)); +} + export async function getWorkSlugs(): Promise { return (await getAllWork()).map((w) => w.slug); }