Scalable MVP Sprint
An MVP you
won't have to rewrite.
Four weeks. Fixed price. From a Lovable / v0 / Cursor prototype, or a greenfield idea, to a production-shipped MVP with real architecture, tests on the load-bearing logic, and a deploy pipeline that survives your second engineer joining the team.
Why most MVPs need a rewrite
Three failure modes show up in almost every prototype-to-product audit I run. The sprint is shaped to make sure your codebase doesn't ship with any of them.
No domain boundaries
Everything imports everything. A change to "user" cascades into 14 files. The codebase becomes the bottleneck, not the team.
Tests are decorative
Coverage looks fine on paper because the MVP has tests for the easy stuff, string formatters, button renders. The actual business logic (billing, auth, integrations) has zero coverage. Refactors break production silently.
No deployment pipeline
The first deploy was a manual SSH session that nobody documented. Now every release is a 90-minute prayer. Rollbacks don't exist. You can't hire a second engineer without rebuilding the whole pipeline.
The 4-week sprint
One discovery week, two build weeks, one polish-and-ship week. Discovery is yours to keep even if we don't continue.
Discovery + architecture
- Domain model + data model locked (written + diagrammed)
- Auth + payments + integration surfaces decided
- Architecture doc with Mermaid diagrams + ADR log
- Phased delivery plan for weeks 2–4
Core build
- Production-shaped repo: monorepo or modular by domain
- Database + migrations + seed data
- Auth flows (email/OAuth) + RLS or middleware policies
- CI green: build + test + lint + type-check on every PR
Feature build + integrations
- The 3–5 user-facing features that define the MVP
- Stripe (or chosen payment) integration with real webhooks
- Email/notifications with retry + dead-letter handling
- Test coverage on every business-logic path (not decorative tests)
Polish + ship + handoff
- Production deploy pipeline with rollback + zero-downtime release
- Observability: logs + error tracking + uptime + per-route timing
- Architecture walkthrough video + deployment runbook
- 2 weeks async Slack support after sprint end
What you ship
A production-deployed MVP plus the artefacts that let you keep building on it without me.
Production-shaped codebase
Modular by domain (not by file type). Real type safety. Every business-logic path covered by a test that would actually catch the bug.
Architecture doc + ADR log
Written architecture overview with Mermaid diagrams. Architecture Decision Records for every load-bearing call (database choice, auth model, deploy target, payments stack).
CI/CD pipeline
PR build + test + type-check + lint as merge gates. One-command deploy. Rollback in < 60s. Preview environments per PR if the stack supports it.
Production deploy
Live on the agreed target (Vercel / Cloudflare / VPS / your AWS). HTTPS + custom domain. Observability wired (errors, uptime, logs).
Handoff package
Architecture walkthrough video, deployment runbook, README good enough that a new hire ships their first PR on day 2.
2 weeks post-sprint Slack
Async questions, code-review feedback on your team's first PRs, sanity checks on the next architectural decisions.
Recent work
Three projects from the last 8 weeks where the methodology above was applied in anger.
RankRush.ai
Lovable → self-managed Astro + Supabase + VPS port
Took an AI SEO tool from a Lovable prototype to a production-shipped self-managed stack, own Supabase instance, Astro marketing site, VPS hosting with nginx, and a Python CLI on PyPI. Phased migration with zero downtime; old Lovable instance kept warm as fallback through cutover.
4 phases shipped · zero-downtime cutover · CLI-controllable from Claude Code
View project →Recall (Android port)
Rust-core → Jetpack Compose + JNI bridge MVP
Greenfield Android client for a Rust-based task manager. Restructured upstream Rust into a 3-crate workspace (TUI / core / JNI), shipped JNI bridge with cargo-ndk, and built a production-shaped Jetpack Compose UI with Koin DI, type-safe nav, and end-to-end P2P sync (Iroh). 22+ merged PRs across both repos in 8 weeks.
Bidirectional P2P sync ≤15s · 197 unit tests passing · clean architecture from day 1
View project →Zufa (AI Nanny platform)
Phase 1 architecture + production-readiness scaffolding
Joined as Fractional CTO for an AI-based content moderation platform pivoting from Chrome extension to native iPad. Delivered Phase 1 architecture doc, technical assessment, immediate-fixes list, and phased delivery plan with hour estimates, the deliverables that turn a "vibes-coded" prototype into a board-ready engineering plan.
Phase 1 packet shipped in week 1 · architecture decisions documented as ADRs
View project →Price your build
Sell speed, not hours. Pick your project size and tell me if it's a fresh start or an existing codebase, you get a price across three speed tiers, paid per milestone. The price moves with how fast you need it.
Other ways to start
Lower-commitment ways in. Discovery is fixed-price in EUR; VAT reverse-charged for EU B2B clients.
Discovery Sprint
€4,000
1 week · architecture + plan
- Domain + data model locked
- Architecture doc + Mermaid diagrams
- ADR log for load-bearing decisions
- Phased delivery plan with hour estimates
- No-fault opt-out: refund or convert to full sprint
Builder retainer
from €2,000/mo
embedded delivery · scope that keeps evolving
- Best when scope keeps evolving
- Same engineer, same standards
- One flat monthly fee, no hourly meter
- Productized work absorbed into the retainer
- Month-to-month, three flat tiers
Build slots are limited to one in flight at a time, booking is on a first-deposit basis. Discovery sprints can run in parallel with one active build.
What this is not
Deliberate exclusions that keep the 4-week promise honest.
Design from scratch
Bring a Figma, a Lovable preview, or a sketch. I build to spec, I don't do brand or visual identity work.
Native iOS / Android in 4 weeks
Native mobile MVPs need 6–8 weeks. The 4-week shape is for web + backend. Native is scoped separately.
Scaled production traffic
The sprint ships an MVP, production-shaped, not Series-B-shaped. Multi-region scaling is a Fractional CTO engagement.
Compliance certification
I bake reasonable security defaults but cannot certify HIPAA / SOC 2 / GDPR DPIA, those need accredited auditors.
Ongoing feature work
Post-sprint feature work runs as a Fractional CTO Builder retainer or a follow-on sprint, not bolted onto week 4.
Code-only handoff
Every engagement ships the codebase plus walkthrough video, runbook, and ADR log. "Code only" deliverables are not on offer.
Related services
Already shipped an MVP? These are the natural next steps.
- 12+
- Years engineering
- 37+
- Projects delivered
- 4
- Production stacks covered
- 150M+
- Users impacted
Questions about the sprint
Why "won't need a rewrite"? Every MVP gets rewritten eventually.
Eventually, sure. But most v1s die inside 12 months, not because the market killed them, but because the codebase did. The sprint exists to push that timeline out by 18–36 months: sane domain boundaries, real test coverage on the load-bearing logic, a dependency surface that can be patched, and CI that catches breakage before users do. You'll still rewrite when scale or pivot demands it. You just won't rewrite because the team can't add a checkbox without breaking three other things.
Who is this for?
Solo founders or 2-person teams who already have a Lovable / v0 / Bolt / Cursor prototype that proves the concept but is starting to crack, and seed-stage teams who hired a contractor for the first 4 weeks of a greenfield build and want a senior pair-of-eyes shaping the architecture from day one. Not a fit if you have an existing in-house engineering team, for that, book the Code Review or Fractional CTO instead.
What stacks do you build in?
Next.js / Node.js / NestJS, Astro, Supabase or Postgres, Stripe, Cloudflare. Native Android (Jetpack Compose + Kotlin) when the MVP needs a real mobile client. Rust for performance-critical cores with JNI bridges into Android. These are the four production stacks I ship in daily, pick from them.
What happens in week 1?
Discovery + architecture. We lock the domain model, the data model, the auth model, and the deployment target. I produce a written architecture doc with Mermaid diagrams + an ADR log + a phased delivery plan. If we discover the scope can't fit in 4 weeks, you get the discovery sprint deliverables and we re-scope before committing further hours, no surprises in week 4.
What if the project takes longer than 4 weeks?
The 4-week sprint is fixed-price for the agreed scope set in the discovery week. If you want to expand scope mid-flight, we either fold it into a follow-on sprint or roll onto a Builder retainer, but the original scope ships in 4 weeks regardless. The fixed-price guarantee is what removes the risk for you; the discovery week is what keeps the price honest for me.
Do you hand off to my team afterwards?
Yes, handoff is part of week 4. You get the codebase, an architecture walkthrough video, a written ADR log, the deployment runbook, and 2 weeks of async Slack support after sprint end for handover questions. I also offer a Fractional CTO arrangement post-sprint if you want me to keep eyes on the codebase during the next 3–6 months.
What is the money-back guarantee?
If after week 1 you don't feel the discovery deliverables (architecture doc, data model, ADR log, phased plan) materially de-risk your build, I refund the discovery sprint in full and we part ways. After week 1 the engagement converts to fixed-price for the remaining scope, no further refund window, but the architecture doc is yours to keep regardless.
Is VAT included in the prices?
Prices are in EUR, ex-VAT. For EU B2B clients, VAT is reverse-charged to you under standard EU rules. An invoice is issued for every engagement.
Not sure if you're ready for the full sprint?
Book a free 15-minute call. I'll tell you honestly whether Discovery, the full Sprint, or something else fits, including saying no if it's not a fit at all.
Book a free call