Software Architecture & Stability Engineering

Software that stays up.

Architecture and stability engineering for systems that have to work. 30 years of designing, hardening, and rescuing production software — .NET, C#, Node.js, and Electron.

When a system has to run for a decade, the decisions made in the first week are the ones that matter.

Architectural consultation See the work

About

Three decades of building software that lasts

I'm a software architect with over 30 years of hands-on engineering experience. My work sits where most projects either succeed or quietly rot: architecture, data integrity, and long-term maintainability.

I don't chase trends. I build systems that are still understandable, debuggable, and extensible years after the original team has moved on. That means deliberate boundaries, explicit data contracts, and code that says what it does.

My core platforms are .NET / C#, Node.js, and Electron — chosen for stability and tooling maturity, not novelty. I'm equally comfortable designing a system from a blank page and walking into an existing codebase to find out why it keeps breaking.

If your problem is "it works, but no one is sure why" or "we can't change this without something else breaking," that's exactly the work I do.

  • Stability first

    Systems designed to run for years, not to demo on Friday. Correctness and longevity over speed of delivery.

  • Architecture that holds

    Deliberate boundaries and explicit data contracts, so the system stays understandable and changeable as it grows.

  • Root cause, not symptom

    Recurring production failures get traced to their origin and fixed — not patched over until they return.

Engineering Solutions

Selected work, as technical case studies

These are not products for sale — they are evidence of how I approach hard, standards-driven systems. Each one: the problem, the architectural decision that mattered, and the stack.

Languages & platforms
  • C# / .NET
  • TypeScript
  • Node.js
Desktop & UI
  • Electron
  • Vue 3
Healthcare & standards
  • HL7 FHIR (STU3 / R4)
  • FHIRPath
Engineering focus
  • System architecture
  • Stability & reliability

FHIR Form Designer

Healthcare · HL7 FHIR
The problem
Clinical questionnaires in healthcare are governed by the HL7 FHIR R4 standard — powerful, but verbose and unforgiving. A single malformed resource breaks downstream systems. Non-developers needed to author valid FHIR R4 Questionnaire resources without hand-writing JSON or learning the specification.
The architecture
A cross-platform desktop application that separates the editing model from FHIR serialization entirely. The UI works against a reactive in-memory domain model held in a central store; FHIR R4 is only projected at the boundary, with FHIRPath used to evaluate the spec's expression logic. This keeps the standard's complexity contained in one well-tested layer and makes the editor resilient to spec changes — while shipping as a single offline binary with no install dependencies.
The stack
TypeScript Vue 3 Electron Pinia FHIRPath Vite

Chosen for offline-first operation and a deployment story that doesn't depend on a browser or a server — packaged as a portable Windows executable and a Linux AppImage.

FHIR Converter

Healthcare interoperability
The problem
Healthcare systems still hold large volumes of data in the older FHIR STU3 format that must be migrated to FHIR R4 — across whole resource directories, without silent data loss. In a clinical context, "mostly correct" is not acceptable, and a one-off script that dies on the first bad file is not usable.
The architecture
A deterministic batch pipeline built on Microsoft's open FHIR Converter STU3-to-R4 Liquid templates, wrapped in a stricter, production-grade CLI. Each resource flows through template-driven mapping → native post-processing → focused field repair → R4 schema validation before any output is emitted. Directory mode runs recursively, isolates per-file errors so one bad resource never aborts the run, and reports loudly. The mapping layer is data-driven, so new mappings don't require rewriting the engine.
The stack
TypeScript Node.js Liquid templates AJV validation HL7 FHIR STU3 → R4

A JSON-Schema validation pass against the FHIR R4 specification runs before output; shipped as standalone native binaries for Windows and Linux, with no runtime to install.

Professional Focus

Senior architecture & stability, on contract

I work as an independent senior software architect and contractor on systems where correctness and longevity matter more than speed of delivery.

Architecture & system design

Greenfield design, or restructuring systems that have outgrown their original shape.

Stability & reliability engineering

Finding and fixing the root cause of recurring production failures — not just the symptoms.

Codebase rescue & review

Assessing inherited or stalled codebases and making them maintainable again.

Domain-heavy integration

Standards-driven systems (e.g. HL7 FHIR) where the data contract is the hard part.

How I engage

Contract or consulting, remote. Typically embedded with your team for a defined scope, or as an architecture reviewer / advisor. I work best where I can own technical decisions and be held accountable for them.

What I don't do

Throwaway prototypes, trend-driven rewrites, or "move fast and break things." If your priority is shipping a demo by Friday, I'm probably not the right fit.

Contact

Let's talk about your system

If you have a system that needs to be designed right, hardened, or rescued — get in touch with a short description of the problem.