Monoliths that move fast - shipped in Ruby on Rails.

Shopify, GitHub, Basecamp — the biggest Ruby on Rails apps in the world are monoliths. Not because they couldn't afford microservices, but because a well-structured Rails monolith ships faster and costs less to operate. Ten years of Rails in production. We know where the framework shines and where it hides the problems you'll find in year two.

  • Rails 8
  • Solid Queue
  • Kamal deploy
  • Modular monolith

Why Entalogics for Ruby on Rails

Four things every
Ruby on Rails app
actually needs.

Rails gives you incredible speed to launch. It also gives you a 2,000-line User model, N+1 queries behind every `has_many`, and a background job queue nobody monitors. We keep the speed and fix the rest.

Performance01

N+1 queries caught before they ship, not after.

Bullet in development, strict query counters in CI, `includes` and `preload` enforced by convention. Rails makes N+1s invisible — we make them impossible to merge.

Architecture02

Service objects with boundaries, not a fat model free-for-all.

Domain logic in service objects and POROs. Models own persistence and validations — nothing else. Controllers stay thin. A new engineer reads the domain in an afternoon, not a month.

State03

Solid Queue over Sidekiq when the job doesn't need Redis.

Rails 8 ships Solid Queue backed by your existing database. Sidekiq for Redis-backed concurrency where throughput justifies it. We pick the right background system for each job shape — not the one someone installed three years ago.

Type safety04

Sorbet or strict RBS where it earns its keep.

Ruby is dynamically typed. That's a feature until the codebase has 50 models and six engineers. We add gradual typing at domain boundaries so refactors surface breaks before production does.

When Rails, when not

Ruby on Rails is a tool.
Not a religion.

Rails is the fastest path from idea to shipped product. It's also a framework that hides complexity until complexity wins. We'll tell you on the first call which side of that line your project sits on.

PICK RAILS WHEN

  • Speed to market matters — nothing ships a CRUD-heavy product faster than Rails with the right conventions
  • The product is content, workflow, or transaction-heavy — ActiveRecord and migrations are genuinely best-in-class
  • Small to mid-sized team that needs convention over configuration
  • You want a monolith that scales to millions of requests — Shopify and GitHub prove it works

CONSIDER OTHERS WHEN

  • Pure API with no server-rendered views — a lighter framework may fit better
  • Real-time heavy with thousands of concurrent WebSocket connections — Rails can do it, but Node.js does it cheaper
  • Your team already ships Django or Spring well — switching won't pay back the migration cost

WE SAY NO WHEN

  • "Rewrite our microservices into a Rails monolith because DHH said so." That's a blog post, not a strategy.
  • "Rails for a real-time multiplayer game backend." Wrong tool. We'll say that before you've paid for a week.
  • "We need this in two weeks and the models aren't defined." That ship has sailed.

What we build with Ruby on Rails

Six product surfaces.
One quality bar.

The shapes of Ruby on Rails work we ship most. Each integrates cleanly into your existing infrastructure.

  • S01

    SaaS platforms & marketplaces

    Multi-tenant architecture, Devise auth, Stripe billing, admin dashboards with ActiveAdmin or Avo. The product surface Rails was born for.

    RAILS 8DEVISESTRIPEAVO
  • S02

    API backends for mobile & SPAs

    JSON APIs with Jbuilder or Alba, token auth, versioned endpoints, rate limiting. A clean API layer that your frontend team doesn't fight.

    RAILS APIALBARACK-ATTACKREDIS
  • S03

    Content & publishing platforms

    CMS-driven sites with ActionText, ActiveStorage, Turbo for live updates. Editorial workflows that don't need a separate headless CMS.

    ACTIONTEXTACTIVESTORAGETURBOPOSTGRES
  • S04

    E-commerce backends

    Solidus or custom cart/checkout built on Rails. Inventory, order management, payment integration — with the transaction safety ActiveRecord provides.

    SOLIDUSRAILSSTRIPESIDEKIQ
  • S05

    Internal tooling

    Replace the spreadsheet. Replace the five spreadsheets. Rails scaffolding for internal tools is still the fastest path from "we need this" to "it's live."

    RAILSHOTWIRETAILWINDPOSTGRES
  • S06

    Legacy Rails upgrades

    Rails 4 to Rails 8, Ruby 2.x to Ruby 3.x, asset pipeline to Propshaft. One upgrade at a time — the current app keeps serving while we modernise underneath.

    RAILS 8PROPSHAFTKAMALSOLID QUEUE

The playbook

Patterns we
ship on repeat.

Battle-tested Rails patterns from production monoliths — not RailsCasts from 2012.

  • P01

    Service objects for domain logic

    Business logic in POROs with a consistent interface. Models stay lean. Controllers stay thin. The domain is readable without running the app.

  • P02

    Strict query discipline

    Bullet in dev, query count assertions in CI. Every `has_many` loaded with `includes` or `preload`. N+1s don't ship — they fail the build.

  • P03

    Hotwire over heavy JS

    Turbo Frames and Turbo Streams for interactive UI without shipping a JavaScript framework. Stimulus for the behaviour that HTML can't handle alone.

  • P04

    Solid Queue by default

    Database-backed background jobs for most work. Sidekiq when Redis-backed concurrency is genuinely required. Less infrastructure, fewer moving parts.

  • P05

    System tests that cover the critical path

    Capybara with headless Chrome for end-to-end flows. Minitest or RSpec for unit coverage. CI runs in under five minutes.

  • P06

    Kamal deploy, zero downtime

    Kamal 2 for zero-downtime deploys to bare metal or cloud VMs. No Heroku lock-in. No Kubernetes overhead for a monolith that doesn't need it.

Signature case

A SaaS marketplace,
rescued from Rails 4 and redeployed on Kamal.

A B2B marketplace on Rails 4.2, Ruby 2.5 — Heroku bills climbing, 25-minute deploys, a flaky 40-minute test suite, and a Sidekiq queue backing up nightly. Upgraded to Rails 8, Ruby 3.3, Solid Queue, and Kamal in 10 weeks. Without a feature freeze.

Before

Rails 4.2 · 25-min deploys · 40-min flaky test suite · Sidekiq backups nightly · $2,400/mo Heroku

After

Rails 8 · 90-second Kamal deploys · 4-min test suite at 98% pass · Solid Queue, zero backups · $380/mo VPS

  • Deploy time−94%
  • Infra cost−84%
  • To fully upgraded10wk
  • Shipped regressions0

Engagement shape

Eight to ten weeks
to a measurable ship.

A typical Ruby on Rails engagement, end-to-end. We upgrade or build route by route — never flag-day. The current app keeps shipping while we work.

  • W01

    Audit + RFC

    Two senior Rails engineers in the codebase. Query profiling, model complexity inventory, background job failure analysis. A ranked, dollarized RFC.

  • W02–03

    Foundation + first route

    Rails 8 baseline, service object conventions, Solid Queue wired in, one production route migrated or built end-to-end. Real metrics in your dashboards.

  • W04–08

    Migrate by route, not flag-day

    Route by route under feature flags. Old and new coexist. Kill-switch on every cutover. Your roadmap keeps moving.

  • W09+

    Cleanup + handoff

    Delete the old. System tests on critical paths. Kamal deployment runbook. Handed to your team — or we stay on retainer.

Stack

Tools we
reach for first.

Picked for production Rails — not tutorial-era gems.

  • FrameworkRails 8 · Sinatra · Hanami · Hotwire
  • LanguageRuby 3.3 · Sorbet · RBS · RuboCop
  • DataActiveRecord · PostgreSQL · Redis · Solid Cache
  • QueueSolid Queue · Sidekiq · Karafka · GoodJob
  • TestingMinitest · RSpec · Capybara · FactoryBot · SimpleCov
  • InfraKamal 2 · Docker · Fly.io · AWS · Datadog · Sentry

Engagement

Three ways
to work with us.

No hourly retainer that bills for "thinking time." Pick a lane that matches your stage; everything is fixed-quote or transparently rated.

FIXED SCOPEone-off build

Ship a Ruby on Rails app, end-to-end.

A defined product, a fixed price, a senior-only team. From RFC to launch in 8–14 weeks.

$15k–$30k

FIXED SCOPE

  • Senior engineers only
  • Fixed quote in week 1
  • Code, infra, runbook — yours
Plan a fixed build
DEDICATED TEAMmonthly

Hire dedicated Ruby on Rails developers.

Embedded engineers in your Slack, your Linear, your standups. A scaled pod of senior Rails engineers, augmenting your team. Pause, resize, end with 30 days' notice.

$5k / eng / mo

PER ENGINEER

  • Same senior bar as fixed-scope
  • Embedded in your team
  • Founder-direct escalation
Hire dedicated Rails devs
ENGAGEMENTcustom

Strategic Ruby on Rails partnership.

A long-term partner for product orgs that need both delivery and judgement — modular monolith architecture, performance program, hiring help.

custom

PROCUREMENT-FRIENDLY

  • Multi-quarter roadmap
  • Architecture & hiring partner
  • Procurement-friendly paper
Speak to the founder
FAQ

Sharp questions,
straight answers.

Monolith vs microservices, Rails upgrades, Solid Queue — the questions we get on every Rails discovery call.
Stay on the monolith. Shopify, GitHub, and Basecamp run Rails monoliths at massive scale. Extract a service only when a specific surface has independent scaling or deployment requirements the monolith genuinely can't handle.
Yes. We upgrade one version at a time — 4→5→6→7→8 — with deprecation warnings fixed at each step. The app stays deployed throughout. Your team keeps shipping.
Solid Queue for most jobs — database-backed, ships with Rails 8, eliminates the Redis dependency. Sidekiq when you need Redis-backed concurrency for high-throughput jobs. Most apps don't need Sidekiq.
Yes. The engineers who write the RFC ship the code. No handoff mid-engagement. Direct access throughout.
Yes. We adapt to your conventions, your gem choices, and your test framework. If something structural needs changing, we flag it in the RFC. If it works, we build on top of it.

Founder-direct

Tell us whatyou're building.

Thirty minutes with the founder. We'll bring a senior Ruby on Rails engineer, the relevant playbook, and a candid read on whether Rails is the right call — or whether your problem needs a different tool.