Developer tooling & SDK engineering
Turning Engineer Scripts Into Operator-Ready Release Software
An industrial release operation ran plant deployments through XL Release — a capable release-orchestration tool — but in practice only its own engineers could drive it: every release was hand-assembled in the tool, with operational records edited by hand in the database and scripts run from shared jump boxes. We turned that into self-service software.
The centerpiece is a data-driven YAML schema that builds out a complete XL Release template automatically — so the team can prototype and stand up a new release in minutes — backed by a strongly-typed .NET SDK over the XL Release API that internal developers can build their own portals on, installable Spectre.Console operator tools, and a guardrailed, audited PostgreSQL administration layer.
Before — a release only an engineer could run
Releases ran on XL Release (now Digital.ai Release) — an enterprise tool that models a release as a template of phases and tasks. It was capable, but in practice only the operator's own engineers could drive it; every deployment cycle began with manual setup:
- Release templates assembled by handbuilt task by task in XL Release for each cycle
- Operational records edited by handa DBA changing data directly in the database
- Scripts run from shared jump boxeswith shared credentials
It worked, but it wasn't *software* an operator could pick up — and engineers stayed in the critical path of every release.
The release path · live
From a runbook to a full XL Release template
An operator validates a release runbook; from that data-driven YAML schema, the tooling builds out the full XL Release template automatically. Per-package tasks fan out to the release board, and every change lands in an append-only audit trail.
One system, six capabilities.
Typed XL Release SDK
A strongly-typed .NET client that wraps the XL Release API in 12 domain services — the stable surface internal developers can build their own portals and tools on.
Data-driven release runbooks
A single YAML schema describes a release; from it, the tooling builds out the complete XL Release template automatically — phases, tasks, and per-package structure — so the team can prototype a new release in minutes.
Operator CLIs + installer
Four installable Spectre.Console tools — single-file binaries with a portable, no-admin installer that runs on locked-down jump boxes.
Per-package release visibility
Template generation became one addressable task per package, so an operator can retry or skip a single package from the release UI instead of replaying the whole cycle.
Guardrailed, audited admin
A PostgreSQL administration layer with environment-aware guardrails, typed-confirmation gates on destructive operations, and an append-only audit trail.
Secure-by-default credentials
Per-user, DPAPI-encrypted credential storage on Windows — replacing shared, plaintext credential files on jump boxes.
The SDK — a typed surface developers build on
At the core is a strongly-typed .NET SDK over the XL Release REST API. Instead of every team hand-rolling HTTP, JSON, and authentication, they call typed domain services:
- 12 domain services, 50+ async methodsusers, roles, folders, templates, phases, tasks, variables, releases, activities, reports, attachments, and subreleases
- Three native auth modesHTTP Basic, Personal Access Token, and OAuth2 — with one-line dependency-injection registration
- Result-based error handlingexpected failures — HTTP errors, validation, auth — come back as a typed Result instead of exceptions you have to anticipate
The payoff: internal developers can build their own web portals on the SDK — a stable API surface — without ever touching the release tool's HTTP, JSON, or auth plumbing.
From a YAML schema to a full XL Release template
A release used to be assembled in XL Release task by task. We replaced that with a data-driven YAML schema — one runbook that describes a release, from which the tooling builds out the entire XL Release template automatically:
- One runbook, a full templatethe schema generates XL Release phases, tasks, and per-package structure end to end, so the team can prototype and stand up a new release in minutes instead of hand-building it
- Validated before it runsa six-stage check (structure, schema, values, domain rules, dependencies, hygiene) with an auto-fix engine that catches problems early
- Versioned and verifiableeach runbook is stamped with IDs and source hashes, so what shipped is exactly what was reviewed
From engineer script to operator self-service.
Author
An operator describes the release in a YAML runbook — a data-driven schema, not hand-built tasks.
Validate
Six checks plus an auto-fix engine catch structure, value, and dependency problems early.
Generate
From the runbook, the full XL Release template is built automatically — one addressable task per package.
Run
The operator triggers the release through the SDK — or a portal built on it — with no engineer in the loop.
Administer
Resets, archives, and credential changes run through guardrailed, fully audited admin tooling.
Safe by default — guardrails and an audit trail
Self-service can't mean unsafe, so safety lives in the software, not the runbook:
- Environment-aware guardrails block destructive operations against production releases; a release's name and environment can't be changed after it's created
- Typed-confirmation and change-ticket gates stand in front of every reset and delete
- An append-only audit trailappend-only is enforced at the database layer, not just in the application, so operational history can't be quietly rewritten
- Per-user, DPAPI-encrypted credentials on Windows replace shared credential files
Tools & stack
- .NET 10
- C#
- Python
- YAML
- Spectre.Console
- Single-file binaries
- No-admin installer
- Windows Client
- Windows Server
- XL Release
- REST API
- 12 domain services
- Result types
- Dependency injection
- JSON
- OAuth2
- Personal Access Token
- HTTP Basic
- DPAPI credential encryption
- PostgreSQL
- Npgsql
- Append-only audit log
- Schema migration
- xUnit
- 400+ automated tests
- Live integration tests
Before & after
Before — engineer-gated scripts
Every cycle was hand-built and engineer-run — release templates assembled task by task, records edited directly in the database, scripts from a shared jump box. Operators waited; engineers were the bottleneck and the single point of failure.
After — operator-ready software
Operators can self-serve releases through installable tools, developers can build their own portals on the SDK, and a new release can be prototyped from a YAML schema in minutes — every change guardrailed and audited. The release process is software now, not a script an engineer has to babysit.
Release automation that only its own engineers could run became software the whole team can build on — a data-driven schema that stands up a new XL Release template in minutes, a typed SDK developers extend, and guardrails and an append-only audit trail baked into the software itself.
Evidence
What changed in the work.
- A data-driven YAML runbook that builds out a complete XL Release template automatically — so the team can prototype a new release in minutes
- A typed .NET SDK over the XL Release API — 12 domain services, 50+ methods, three native auth modes — that internal developers can build their own portals on
- Six-stage runbook validation with an auto-fix engine; every package stamped with IDs and source hashes
- Per-package release visibility — retry or skip a single package instead of replaying the whole cycle
- Guardrailed, audited release administration on PostgreSQL, with per-user DPAPI-encrypted credentials
- 400+ automated tests across the solution, including live integration tests against XL Release


