keep it that way.Software product retainers. Bug fixes, security patches, feature work, and a senior engineer who knows the codebase. Month-to-month. No lock-in.
A dependency goes EOL. A payment integration breaks silently. A query runs slow until it times out under load. The build worked when it shipped — and then nobody touched it for four months. By the time a user complains, the change that broke it is buried behind thirty unrelated commits in the framework you're running on.
Monitoring runs in the background. Dependency updates, security patches, and refactors happen on a schedule. Bugs get a real diff and a real review before deploy — not a vibe-coded one-liner. Feature work runs through the same spec-first pipeline as a Build engagement. You get a monthly report that's an actual artifact, not a status template.
Every tier includes monitoring, security patches, dependency upgrades, and a senior engineer who reviews every diff. The size of the engagement is what changes — not the standard of the work.
For live products that need to stay healthy without sprouting new features every month.
// month-to-month · cancel anytime
For live products that ship new things every month — not just keep the lights on.
// month-to-month · cancel anytime
For products where we're effectively the engineering team — roadmap, architecture, delivery.
// month-to-month · cancel anytime
// billed monthly · 30 days notice to cancel · no long-term contract
We capture context — codebase, deploy pipeline, monitoring, dependencies. You're documented before the first invoice.
Anything beyond a one-line fix gets a spec. Small for small things, full for full things. The same discipline as a Build engagement.
Every change goes through the pipeline — diff review, senior sign-off, deploy. Commit messages explain what changed and why.
End of month, you get a report. Not a status update — a real artifact of what shipped, what risk got retired, what's worth watching.
Yes — that's most of our retainer work. Onboarding starts with us reading the codebase end to end and writing a context note that captures architecture, dependencies, deploy flow, known issues, and risk. If we think we can't responsibly maintain it, we tell you in the discovery call. We've turned engagements down. We'll tell you honestly.
Most modern web stacks. Node, TypeScript, Python, Go, Rails, Next.js, SvelteKit, Django, FastAPI. Postgres, Mongo, Redis. Vercel, Netlify, AWS, GCP, Cloudflare. We'll evaluate any stack honestly in the discovery call — including legacy ones. If your stack isn't a fit for us, we'll say so.
We'll tell you before we go over. You can upgrade to the next tier at any point, or we'll quote additional work outside the retainer as a fixed-price piece. We never do surprise billing. If a month is consistently over allocation, we'll suggest the right tier for what you actually need.
Yes. All tiers are month-to-month with 30 days notice. No long-term contract, no lock-in. If you cancel, we hand over the full context note, deployment guide, monitoring config, and a clean repo so the next team can pick up without friction.
A freelancer is one person whose calendar is a lottery. A retainer is a team — engineer, reviewer, and a documented pipeline that runs whether or not any single person is on holiday. Every change is reviewed by a second senior engineer before it ships. Every month produces an artifact, not just an invoice.
Then a retainer isn't the right offer. Transform is — we install spec-first delivery in your engineering org over 3–5 weeks. We'll tell you in the discovery call which one fits.
30 minutes. Tell us what you're running. We'll tell you which tier fits, what onboarding looks like, and whether we're the right match. If we're not, we'll say so.