Alpha

What I can share

Alpha is a real-time autonomous system that I rebuilt entirely on a clean foundation. The project is private: I don't detail its functional logic, but it embodies the level of engineering rigor I carry into all my work, systematic root-cause fixing, zero cosmetic patches and verifiable safety nets.

My role

Full solo design and delivery: architecture, Python/FastAPI backend, React/TypeScript frontend, Tauri/Rust desktop client, PostgreSQL database and migrations, and deployment infrastructure (containerization, reverse proxy, CI). The project stands out as much for its functional density as for the rigor of its process: upfront specifications, regression tests as structural guardrails, systematic audits and a forensic journal of resolved incidents.

Technical capabilities

• Real-time autonomous pipeline: a continuous loop of scanning, decision, control and execution, with tracking and after-the-fact reconciliation.
• Multi-mode architecture: four execution modes (from simulation to full execution), toggled from a single configuration point.
• Native desktop client: a Tauri application (Rust + WebView), packaged cross-platform, with secrets stored in the operating-system keychain.
• LLM-assisted decision layer: cascading multi-provider orchestration with fallback, cost tracking, caching and rate limiting.
• Runtime safety layer: guardrails and invariants wired end to end, able to halt the system on an anomaly.
• State reconciliation and drift detection between the internal state and its external counterpart.
• Observability: structured logging, diagnostic points, metrics and health probes.
• Dual-pool data routing: cross-cutting control state and per-session data kept separate, with scoped migrations and typed access.

Engineering challenges

• Multi-mode consistency without divergence: the risk of a system that both simulates and really executes is that the two paths diverge. The answer is a composite configuration Single Source of Truth, identical code whatever the mode, made tamper-proof by tests that parse the AST and reject any mode condition outside the dedicated module.
• Cold-boot state rehydration: a restart must rebuild the exact state of the active session. The 'switch' and 'cold-boot' paths were unified, and 'kill + respawn' smoke tests verify the real behavior an in-process CI never sees.
• Execution-context dependence: relative paths, cross-namespace imports and a test transport short-circuiting the lifecycle: three sources of bugs invisible in CI but fatal at runtime, resolved with absolute path resolution, import discipline and integration tests exercising the real lifecycle.
• Physical test / production isolation: a real incident showed that destructive tests on a shared database could corrupt the integrity of a live session. The safeguard: a deny-list guardrail (host:port) preventing any test from touching the production instance, backed by a regression test.
• Frontend / backend synchronization: the desktop app reconciles its persistent local state with the server source of truth on mount, via an explicit decision tree, and disciplines state selectors to guarantee correct re-rendering.
• Dual-pool database routing: separating cross-cutting control state from per-session data, with scoped migrations and typed access, enforced by conformance tests.

Scale

A mature, robust system, in production and actively maintained.

• A dense, accomplished system, deployed in production and closely tended day to day.
• Built for reliability: every critical behaviour is protected by automatic safeguards and continuously checked invariants.
• A test suite larger than the codebase itself, keeping every change safe.
• Strict quality gates on each change, to ship without breaking what already works.