Ruby on Rails since before 1.0. Still the fastest way to ship.
Greenfield apps, MVPs, modernization, Rails 8 upgrades, performance work. Two-week sprints, daily demos, fixed price agreed before we start. You own the code from day one.
Production Rails apps, not portfolio pieces.
Greenfield Rails 8 apps
Marketplaces, SaaS dashboards, internal tools, B2B portals. 14-day fixed-price build, kicking off with the hardest part of the spec, ending with a deployed app on your domain. We never bring a junior team.
Rails upgrades, especially the painful ones
Rails 5 to Rails 8, Postgres versions, Ruby upgrades, Sidekiq → Solid Queue, Redis → Solid Cache. The kind that someone said would take six months and you've put off for two years. We have a runbook.
Performance work and rescue jobs
N+1 query hunts, Postgres index audits, cache layering, background-job redesigns, Skylight/Scout deep dives. When an app that should be fast isn't, we find out why and we fix it.
Modernisation of legacy stacks
Moving off Heroku to Kamal-on-Hetzner, off Sidekiq Pro to Solid Queue, off SPA front-ends to Hotwire. Less infrastructure, less licence cost, less surface area for things to break.
Day-by-day. No vibes.
A typical 14-day fixed-price engagement. We will never tell you "soon." We will tell you what's shipping today, today.
Two-hour call. NDA. Spec written together.
You walk in with a problem, not a brief. We turn it into a one-page spec and a fixed price before lunch. If we can't, we say so.
Deliverable: signed spec + priceCode in your GitHub. Staging URL by EOD.
We don't believe in "setup weeks." Rails 8 boilerplate, CI, Kamal deploy, staging on your domain — all done in a day.
Deliverable: deployable repoThe hard half ships first.
The riskiest, most uncertain part of the spec — the integration that might not work, the data model that might collapse — is built first. Daily 15-min Loom updates with what's working and what isn't.
Deliverable: hard part live on stagingYou touch the product. Out loud.
One-hour demo where you click through everything and react in real time. The list of changes goes straight into Sprint 2. No JIRA. No "story points."
Deliverable: prioritized change listPolish, edge cases, the rest of the scope.
Now that the architecture is proven, the rest is craftwork. AI types the boilerplate. We type the parts that matter: error handling, security, the bits an LLM gets subtly wrong.
Deliverable: feature-complete appYou and your team try to break it.
We sit on a call while you find every edge case. Bugs go red on a board you can see. Most are fixed in the same call.
Deliverable: signed-off buildLive. Domain, SSL, monitoring, runbook.
Deployed to your infrastructure (or ours, your call). Sentry, uptime monitoring, a one-page runbook for whoever's on call. You own the keys.
Deliverable: production app + handoverIt's a phone call. That's the worst it can get.
No discovery deck. No 45-minute "qualification" call. 30 minutes, your problem, my opinion. If we're a fit, you'll know by minute 12.