The practice
I work where the interface, service, database, external systems, and operating reality cannot be separated into tidy assignments without losing the truth.
The operating method
The order matters. Each step changes what is safe to do next.
Identify the live source, authoritative data, real constraints, and assumptions that have been repeated without proof.
Open the method → Then · DecisionState what must remain true, how the result will be checked, what would reject it, and how the previous working state returns.
Open the method → Always · ControlConvert every discovered weak point into a test, invariant, comparison, alert, or operating rule that remains after the incident.
Open the method →A practice, not a résumé
Experience helps me recognize the failure pattern. Evidence lets me challenge it. Judgment determines what is allowed to become real.
My New Jersey paramedic license requires continuing education as medical protocols change. My engineering practice follows the same discipline: formal study, daily technical research, and direct trials of new tools on work that can be observed and measured.
The working loop is simple: observe, learn, test, judge, apply, monitor. MIT's 6.00.1x supplied structured computer-science study; AI TraceVector Alpha shows the other end of the loop, where current ideas meet implementation and have to prove their usefulness.
Selected casework
Client identities and repositories remain private. The decisions, constraints, and engineering method are shown.
A modern web application was built against the same live database used by the existing desktop system. Both could operate during transition, so the business chose the cutover when the evidence was ready.
The integration was designed around reconciliation and diagnostics, not merely successful requests. Each missing document or form submission had to produce enough evidence to distinguish vendor behavior, credentials, source data, and ingestion logic.
A live PHP application had competing directories, stale backups, and two versions that both claimed to be current. Deployment evidence and behavioral differences came before any code change.
Different models can draft, inspect, and challenge the same work. Architecture, data authority, release, and irreversible actions remain separate decisions supported by direct evidence.
Current breadth
The technology changes with the constraint. Everything below is load-bearing in current or recently delivered work.
The product record
Client and private-product names remain closed. The system, operating constraint, technology, and relevant public evidence remain visible.
A coordinator drives tiers of local and cloud models to propose and stress-test trading strategies; a fixed statistical evaluation battery — permutation testing, deflated Sharpe, regime stratification, bootstrap drawdown tails — decides what survives. Every candidate runs in an isolated worktree, so hundreds of experiments can run without contaminating each other.
A low-code-generated application carrying years of accumulated business rules, rebuilt as a progressive web app on .NET while its SQL Server 2019 back end stays live. Schema changes go through reviewed migrations, not through a designer.
A second rescue off a different low-code generator, this one under a hard constraint: the database schema could not be touched at all. The new front end had to fit the existing model exactly rather than negotiate with it.
Pulling documents and form submissions out of a third-party fleet-operations API into an operational database, with the ingestion diagnostics to explain why any given record did not arrive. Credentials are read at runtime from a controlled table — never compiled into source, never committed.
A twenty-year-old Access application replaced by a web app that reads the same live SQL Server database the old one still uses — so both run against the same data during the transition and the business never stops billing. Cutover by choice, not by big-bang.
Required classes per job role, actual training records, competency matrices and audit reports. The interesting part is the source control: every form, report, query and module is exported to text, so a thirty-year-old desktop database gets real diffs and real code review.
The generalisation of that idea: tooling that takes an Access application apart into reviewable text, drives it through git, and puts it back together — so a whole category of business-critical software that has never been under version control finally can be.
A safety-first social product built as a monorepo across web and every Apple and Android surface that matters — phone, tablet, watch, TV, and headset — off one shared schema and one shared package layer.
A PHP and JavaScript MVVM application recovered off a live server with no clean source history — competing directory copies, stale backups, and a hundred-line diff between two versions both claiming to be current. Establishing what the real source was came before any modernisation could start.
One conduit every model request in the ecosystem flows through. A control plane that decides which model answers under what budget, a data plane that executes the tokens, and a resource plane that schedules the GPUs underneath. Consumers ask for a capability; they never name a machine or a provider — so local and commercial tiers are a routing decision, not an architecture. Underneath it, cross-project vector-backed retrieval: context digested once into a typed, queryable store rather than re-read from raw text every session.
An interactive coding environment pointed at self-hosted models instead of a vendor endpoint, with review gates, completeness guards and write guards wired into the loop — the harness that decides whether a model's claim of "done" is true.
This site and the firm's. Static-generated, edge-hosted, with a retrieval assistant grounded on my own published writing and a contact path that runs through my own Worker — bot protection and delivery included, and not one byte routed through a marketing stack.
Proof without exposure
Private client work can remain private without reducing every claim to “trust me.”
I publish the method, the decision, the failure, and the control that followed. Client identities, credentials, operating data, and valuable parameters stay closed. The two white papers show how that balance works in practice.
A system nobody wants to touch, an integration that fails quietly, or a build that has to be standing by a date already promised—that is the work.