Engineering
Build
Production-minded code with the boring parts done right: validation at the boundary, audit logs on every action, tests green before handoff. From .NET services to single-file WebGL experiments.
Portfolio/Dossier Nº 001/Open to work
I build systems that verify — tooling that intercepts wire fraud, pipelines that prove two documents agree, and the written record that lets a team trust both. This page is one of those systems: hand-coded, zero templates, rendered live in front of you.
I work where money moves and mistakes are expensive — so I build the checks, tools, and paper trails that keep both honest.
My background is in financial-operations work with real stakes: wire-instruction verification, closing-agent vetting, and the fraud-prevention workflows behind real-estate settlement. That world taught me a habit I bring to every role — never trust a value you haven't verified, and never ship a process you can't explain in writing.
Somewhere along the way, the tooling I built to make my own work faster became the work. A local OCR cross-checker. An API wrapper with a full audit trail. Validation pipelines in PowerShell. Formal handoff documents an engineer can build from without a single follow-up question. I sit comfortably between operations, analysis, and engineering — fluent enough in each to translate among all three.
I'm now looking for a role that lives in that overlap: development, business analysis, or data analysis — anywhere precision is treated as a feature, not a formality.
Build
Production-minded code with the boring parts done right: validation at the boundary, audit logs on every action, tests green before handoff. From .NET services to single-file WebGL experiments.
Measure
Turning messy operational reality into numbers someone can act on — OCR extraction, fuzzy cross-matching, validation workbooks, and the queries behind them. If it can be checked, it gets checked.
Verify
The connective tissue: requirements and change requests engineers can build from, process documentation that survives an audit, compliance research across state lines, and clean cross-team handoffs.
Each thumbnail below is drawn live by code — a generative sigil seeded by the project's own name, so no two are alike and none is a stock image. Open a case file for the full record.
A two-project solution — a Web API wrapper plus a Blazor Server front end — built in front of an existing wire-account verification system used in real-estate settlement. The wrapper adds the guarantees the raw platform didn't have: hardened document intake, traceability, and a clean surface for operations staff.
Every decision optimizes for auditability. If a wire instruction moves through this system, there is a record of who touched it, when, and what the system verified.
Wire fraud lives in the gap between two documents that were never compared carefully. This tool closes that gap: it extracts text from native and scanned PDFs, normalizes the mess OCR produces, and cross-verifies six fields — account, routing, names, and beneficiary details — between a wire instruction and its supporting evidence.
It runs entirely on the analyst's machine. No document ever leaves the desk — a deliberate privacy-by-design decision for material this sensitive.
Verification work arrives as email — unstructured, high-volume, and easy to lose. This dashboard sits on top of that intake: it parses what arrives, sorts it into workstreams, and shows status so nothing silently ages in a shared inbox.
It's the pattern behind most of my tooling: take an operational process that lives in someone's head and inbox, and give it structure, visibility, and a paper trail.
Traumrunde — "dream lap" — is what happens when the discipline of verification work meets a lifelong motorsport obsession. It's a hyper-detailed driving prototype built from scratch in the browser: no game engine, no asset store, one file.
The flat-six engine note isn't a recording — it's synthesized live with the Web Audio API, pitch- and load-mapped to a hand-rolled vehicle physics model. The same care that goes into a verification pipeline goes into a rev limiter.
The hero animation on this very page is a cousin of this project — same renderer, same appetite for building the hard thing by hand.
Every wire I've checked, every field I've cross-matched, every magic byte I've validated says the same thing: confidence is earned per item, not granted per source.
A tool without a handoff document is a liability with a UI. I write the README, the change request, and the runbook — so the next person builds instead of reverse-engineers.
Audit logs, expiring links, tests before handoff — none of it is glamorous, all of it is why the work holds up in production. Flair goes in the pixels; discipline goes in the pipeline.
Exact requirements, exact column counts, exact reproduction steps. Precision spends my time to save everyone else's — that trade is almost always worth it.
I'm open to developer, business-analyst, and data-analyst roles — especially where operations meet engineering. Repositories marked private can be opened to interviewers on request.