// about
Hi, I'm Ed.
The honest reason I do this: I love shipping. The moment a project goes from idea to finished — live, working, looking the way it should — is the best feeling I know. I build for that feeling, which means I build to finish.
Scope and price are fixed before anything starts. What stays flexible is the route to them. I don't lock a step-by-step plan I'll be wrong about by Thursday — I start from what the work has to achieve, build the smallest real version of it, and let what's actually on screen decide the next move. You see it as it happens, so nothing is a surprise at the end. The part I care about most is invisible: the small tweaks, the edge cases, the details nobody would ever notice. But if I notice one, I can't unnotice it — so nothing ships until everything within my power is accounted for.
I'm a Riga-based developer who takes projects end-to-end — design, build, and ship. Most firms setting out to hire software developers are really trying to get one thing built properly; this is that, without the bench or the handoffs. The angle is deliberately narrow: firms whose business is more credible than their website, and the software that sits behind it. If a job isn't mine, I'll say so and point you at whose it is.
That focus is kept honest by depth. I designed, built, and shipped a full game — ChampChase, a story-driven boxing RPG — solo, to beta on iPhone and Android, along with the pipeline that built it.
"If there's a will, there's a way."
// how I work
Hire one senior developer, not a bench.
No handoffs lost in translation, no "that's not my department." From the first sketch to the deployed result, it's the same pair of hands — which means it gets done, and it gets done coherently.
You talk to the person who does the work. Scope stays honest, decisions stay fast, and nothing falls between roles — because there's only one.
// the method
Directed, not vibe-coded.
The fair question to ask anyone who ships this fast on their own. Here's the answer before you have to ask it.
Every architectural and product call is mine, and so is every decision to reject one. I run an AI-orchestrated pipeline to build against those calls — a planning layer that turns intent into exhaustive build instructions, an implementation layer working in plan-then-review-then-execute cycles — and I sit in the middle red-teaming every plan and running the verification myself. The judgment and the refusal are the scarce parts.
Which raises the obvious question: why hire me instead of the same tools? Because this is what those tools produce with no verification layer on top — a privilege column that looks completely plausible and is writable from the browser; a payment status that flips on a redirect instead of a signature-verified webhook; a storage rule that holds in the interface and not against a direct API call. Every one of them reads fine in review and fails the moment somebody hostile looks at it. Catching them isn't a prompt. It's knowing they're the things to go looking for, and refusing to sign off until each one is asserted in a test that runs again on every change.
The refusal is the part you're actually buying. When the isolation suite on my own product came back one assertion short of clean — 160 of 161, at the size the suite was then — nobody was waiting on that call but me. I didn't ship it. I found the one, fixed it, and re-ran until every assertion passed.
Sound like the person your project needs?