Independent software engineering · UK
Web platforms, payments, AI and reliable systems for businesses that run on software — online shops, training businesses, service companies. Built to stay maintainable, delivered by one accountable engineer.
Direct technical ownership — from architecture to implementation.
Intelligent systems. Elegant design.
Services
One accountable engineer for the whole lifecycle — from first conversation to running in production. Describe the problem; I'll scope the work.
Online shops and business websites with payments that actually work.
The portals, admin panels and integrations that replace the spreadsheet chaos.
AI integrated where it earns its keep — pragmatic, human-reviewed, secure.
Systems that stay current, backed up and restorable — the data-loss scare ends.
Move off aging platforms and legacy systems without the risky rewrite.
Describe the problem, not the solution. A conversation is cheap; a wrong architecture is expensive.
Talk it throughSelected work
Evidence over marketing: the problems, constraints and structures behind systems designed and built in professional engagements and ongoing products.
Long-horizon engineering assisted by AI raises a practical question: does an AI-orchestrated workflow hold up at scale, and what does it actually cost?
Artifact-driven delivery (ICM/MWP): roadmaps, story cards, handovers and a decision log as the system of record; LLM-orchestrated build with human review gates — deterministic process, AI leverage, human accountability.
19 days, ~57–95 hours of human effort, 7,902 AI requests, ~916M reported tokens — $8.53 total inference cost (~$0.11 per human development hour). AI leverage measured in durable output, not token counts.
Every internal tool and operational interface needs its own bespoke frontend — duplicated effort, drifting UX, slow iteration on small changes.
A backend-driven declarative UI runtime: the server describes the interface as data, one client renders it. Admin panels, portals, monitoring surfaces and reporting views come from a single engine.
Operational interfaces without frontend churn — the runtime behind DelfinFlow's portal direction (ui-runtime-web), in active development.
A solo service business runs invoicing, payments and client communication across email and spreadsheets — the delivery methodology needs an operational surface.
Deterministic email pipeline, centralised invoicing, payments and communication, agentic delivery pipelines with human approval gates — every event recorded, every state reproducible.
A dogfooded operational backbone: DelfinFlow's own business runs on it, and the same surface becomes the client portal for the businesses it serves.
A production Linux workstation drifting into an unreproducible state — multiple package managers half-installing things, obsolete tooling, gigabytes of caches, update channels only touched when something broke, backups never restored.
One-command update automation across eight update channels, disk reclamation and hygiene, toolchain consolidation (uv-first Python, LTS-only Node), committed runbooks — every result measured before and after.
~10 GB reclaimed on a 29 GB disk in a single session, one source of truth per toolchain, and a system that maintains itself — with tested recovery when the disk dies anyway.
A training business ran courses, quoting, payments and learner communication across scattered tools and spreadsheets — one operational view was missing.
Modular multi-module system (HMVC), Stripe & GoCardless payments, email notifications, an interactive process flow that unlocks course parts as learners progress.
One platform owning the full operational lifecycle — bookings, payments, content and learner progress, with commerce integrated rather than bolted on.
High-volume error events with ambiguous grouping — cascade detection needed deterministic semantics, not heuristics.
Rust core for the business logic, a thin TypeScript API layer, hierarchical logging with controlled grouping. Foundation of the SurfLogs product.
Deterministic error grouping at scale — a developer-facing product in active development.
Representative work from professional engagements and products in development. Case details available under NDA.
R&D · Energy systems
An energy platform for solar battery systems — monitoring, control and optimisation with lifespan prediction, built on the practice's own UI runtime. Designed for households and businesses that want real numbers, not estimates.
Approach
You engage the engineer responsible for architecture and implementation — no sales layer, no account manager, no handoffs.
Requirements and constraints captured precisely — scope deliberately kept where direct ownership is an advantage.
Boundaries, interfaces and data flows decided before complexity gets expensive. Structure first, code second.
Production engineering with testing, monitoring and verified backups. No partial solutions — if it can run two ways, both are handled.
Maintenance, monitoring and support — systems that remain understandable to whoever maintains them later.
Built for direct ownership. Projects are deliberately kept within a scope where one accountable engineer is an advantage: architecture, implementation and technical decisions stay connected rather than passing through organisational layers. Where a project needs additional specialist capacity, architecture and technical direction remain clearly defined while extra implementation capacity can be introduced.
About
DelfinFlow is the independent engineering practice of **Dominik** — software engineer and architect with 10+ years building production systems across backend, frontend and infrastructure.
The practice combines engineering with formal teaching experience (four years, college level). That background shapes the architecture: systems should be understandable not only to their original author, but to the people who will maintain them later.
Away from client work: open-source libraries (prutill, state-radar, singleton-registry), Web Components (ShadowKit), and ongoing research in Rust/GTK, game engines and simulation.
Methodology and AI tooling is open source too: the Model Workspace Protocol for deterministic delivery, the Engram reasoning kernel, and the JigsawFlow application pattern.
Rust · Python · Node.js
TypeScript · React · PHP · JAMstack
PostgreSQL · Elasticsearch · ECharts
Linux · Docker · Jenkins · systemd
Contact
A straight answer and a clear proposal — usually within one working day. Fully digital and online-delivered — UK-based, working with clients across the UK and Europe.
hello@delfinflow.devLinkedInNot sure whether it fits? The best-suited list in the approach is a good start — a conversation is cheap.