Skip to main content

Developer tooling & SDK engineering

Turning Engineer Scripts Into Operator-Ready Release Software

EnterpriseGlobal industrial enterprise — release automation for production plant systems

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.

12XL Release services in the SDK
50+typed SDK methods
6runbook validation checks
4installable operator tools
400+automated tests

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.

01

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.

02

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.

03

Operator CLIs + installer

Four installable Spectre.Console tools — single-file binaries with a portable, no-admin installer that runs on locked-down jump boxes.

04

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.

05

Guardrailed, audited admin

A PostgreSQL administration layer with environment-aware guardrails, typed-confirmation gates on destructive operations, and an append-only audit trail.

06

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.

01

Author

An operator describes the release in a YAML runbook — a data-driven schema, not hand-built tasks.

02

Validate

Six checks plus an auto-fix engine catch structure, value, and dependency problems early.

03

Generate

From the runbook, the full XL Release template is built automatically — one addressable task per package.

04

Run

The operator triggers the release through the SDK — or a portal built on it — with no engineer in the loop.

05

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

Languages & runtime
Operator tooling
  • Spectre.Console
  • Single-file binaries
  • No-admin installer
SDK & integration
  • XL Release
  • REST API
  • 12 domain services
  • Result types
  • Dependency injection
Auth & security
  • OAuth2
  • Personal Access Token
  • HTTP Basic
  • DPAPI credential encryption
Data & audit
  • Npgsql
  • Append-only audit log
  • Schema migration
Quality
  • 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