Systems that
don’t ask for trust.
They show proof.
Backend infrastructure. Controlled AI execution. Security. Verification.
This site is also a working system.
Sign in, run jobs, buy test credits, and inspect the flow. The metrics below are read from this live demo environment.
Live metrics from the Clerk / Stripe / job execution demo · uptime 84h
Live telemetry from the local Alex AI inference gateway — a separate system from the demo metrics above.
What the demo records.
Clerk authenticates, Stripe test checkout grants credits, the backend dispatches a job, and the ledger records the event for dashboard inspection.
Controlled AI Execution
AI can do substantial engineering work without surrendering control of scope, execution, verification, evidence, or completion. RailTaskLite keeps the operator decision point explicit before work is promoted.
Auditable.
Shippable.
Auditable.
Shippable.
What I build.
Authenticated backend systems with billing flows, job state, audit ledgers, runtime telemetry, and operator-visible deployment evidence.
Authenticated Execution Paths
Clerk-backed sign-in protects dashboard routes before demo actions are available.
Billing Event Flow
Stripe test checkout grants credits through webhook handling and records the ledger event.
Backend Boundaries
FastAPI services expose health, metrics, job, license, and dashboard-facing API surfaces.
Job State Tracking
Demo jobs move through dispatch, credit deduction, queue depth, pass rate, and visible history.
Audit State
Credit and execution events are stored as inspectable records instead of hidden side effects.
Deployment State
Dockerized frontend, backend, Postgres, Redis, and monitoring services run behind the public site.
Local AI Telemetry
The Alex AI gateway exposes aggregate request state, answer counts, and recent latency.
Operator Evidence
Release work is framed around gates, rollback boundaries, and records an operator can read later.
What this means in practice.
Clients buy reduced risk, faster debugging, and clear proof — not abstract orchestration language.
Launch safer.
Auth, billing, credits, and jobs are verified before users touch them. Known boundaries before go-live, not discovered afterward.
Debug faster.
Every meaningful action leaves a trace: job state, ledger event, webhook result, runtime status. No forensic archaeology when something breaks.
Ship with rollback.
Changes are scoped, auditable, and reversible. Not "pray and deploy" — a structured path from commit to production with a defined way back.
Use AI without chaos.
AI can accelerate engineering work, but the system — not the model — decides what is allowed to reach production. Bounded execution, not unconstrained output.
Infrastructure and security aren’t an afterthought.
The same discipline behind the code runs the systems underneath it.
Infrastructure
- Public exposure kept to a minimum — internal services are never reachable directly.
- Services and data stores are isolated from one another, not sharing state that doesn’t need to be shared.
- Backups and health monitoring run on a schedule, automatically, not by hand.
- Recovery paths are defined before a change is treated as complete.
Security
- Administrative surfaces are network-restricted, not just password-protected.
- Rate limiting stops abusive traffic before it reaches application code.
- Hardening and dependency posture are checked on a schedule, not once at launch.
- Verification records stay readable after the work is complete.
A working automated video product.
Vrillsy runs today as a public demo environment with authentication, checkout, job execution, and billing paths available to inspect. Product development priority is currently focused on RailTaskLite; commercial distribution is open to the right partner with creator-market access, customer acquisition capability, or complementary commercial reach.
Payment flow runs in Stripe test mode — no real charges are processed.
A green test suite is not
a release-ready artifact.
Clean-clone coherence, secrets hygiene, auth enforcement, and payment isolation are release concerns, not just unit-test concerns.
A release record needs a scoped way back: what changed, what can be undone, and what must be left untouched.
The useful artifact is readable after the session closes: what ran, what passed, what needs review, and how to recover.
Systems fail at boundaries, not slogans. The response is records, gates, and scoped recovery.
Stage transitions are visible.
Job state, ledger events, runtime status, and completion output are kept as inspectable surfaces.
Status is explicit.
Runtime surfaces expose PASS, REJECTED, BUSY, and ERROR states instead of hiding execution behind a generic green checkmark.
Reversal is scoped.
The record distinguishes what a session touched from what it did not, so recovery does not become another uncontrolled change.
Need the hard parts built with visible control?
Auth, billing, job execution, AI runtime orchestration, and reliability review work, with the live demo available before a call.