Rails (Avo) vs Remix (Epic Stack): Ruby vs JavaScript Full-Stack

Two Opinionated Stacks

Some frameworks give you choices. Avo (Rails) and the Epic Stack (Remix) give you answers.

Both are built by experienced developers with strong opinions about how web applications should be built. Avo comes from the Rails tradition of convention-over-configuration — define your models, get admin panels, CRUD interfaces, and dashboards automatically. Epic Stack comes from Kent C. Dodds' philosophy of web standards, progressive enhancement, and testing-first development.

These are among the most opinionated starters in their respective ecosystems. If you agree with their opinions, you get massive productivity. If you disagree, you'll fight the framework.

TL;DR

Avo ($0-$149/month, Rails/Ruby) auto-generates admin panels and CRUD interfaces from your Rails models — define a resource, get instant search, filters, actions, and dashboards. Epic Stack (free, Remix/TypeScript) is Kent C. Dodds' opinionated full-stack template with comprehensive testing, progressive enhancement, and web-standard patterns. Choose Avo for rapid admin panel and data management tool development. Choose Epic Stack for well-tested, production-grade web applications with progressive enhancement.

Key Takeaways

Completely different use cases. Avo excels at admin panels and data management. Epic Stack excels at customer-facing web applications.
Avo generates UI from data models. Define a Rails model, get a complete admin interface. Epic Stack requires building every screen manually.
Epic Stack has the best testing setup of any boilerplate — Vitest, Playwright, MSW, Testing Library all pre-configured.
Ruby vs TypeScript is the language choice. Rails' metaprogramming makes code concise. TypeScript's type system makes code safe.
Avo has ongoing costs ($99-$149/month for premium features). Epic Stack is completely free.
Epic Stack follows web standards — progressive enhancement, <form> elements, HTTP caching. Avo follows Rails conventions.

Feature Comparison

Core Features

Feature	Avo (Rails)	Epic Stack (Remix)
Admin panel	✅ Auto-generated (core feature)	❌ Build your own
CRUD generation	✅ Automatic from models	❌ Manual
Authentication	✅ Devise	✅ Custom (cookie-based)
Authorization	✅ Pundit integration	✅ Permission utilities
Database	✅ Active Record (PostgreSQL)	✅ Prisma (SQLite → PostgreSQL)
Testing	✅ RSpec, Capybara	✅ Vitest, Playwright, MSW, Testing Library
Email	✅ Action Mailer	✅ Resend
File uploads	✅ Active Storage	✅ Custom implementation
Background jobs	✅ Sidekiq/Solid Queue	❌ Manual setup
WebSockets	✅ Action Cable	❌ Manual setup
Caching	✅ Rails cache (Russian doll)	✅ HTTP caching
Search	✅ Built into Avo resources	⚠️ Manual (SQLite FTS)
Monitoring	✅ Rails dashboard	✅ Sentry integration
Progressive enhancement	❌ Turbo/Hotwire	✅ Core philosophy
Payments	⚠️ Manual (Pay gem)	❌ Manual

Avo's Admin Generation

This is the feature that makes Avo unique. Define a resource:

class Avo::Resources::Product < Avo::BaseResource
  self.title = :name
  self.includes = [:category, :reviews]

  def fields
    field :id, as: :id
    field :name, as: :text, required: true, sortable: true
    field :description, as: :trix
    field :price, as: :number, prefix: "$"
    field :status, as: :select, enum: ::Product.statuses
    field :category, as: :belongs_to, searchable: true
    field :reviews, as: :has_many
    field :created_at, as: :date_time, sortable: true
  end

  def filters
    filter Avo::Filters::StatusFilter
    filter Avo::Filters::PriceRangeFilter
  end

  def actions
    action Avo::Actions::PublishProduct
    action Avo::Actions::ExportCSV
  end
end

From this, Avo generates:

Index page with sortable columns, search, and pagination
Show page with formatted field display
Create/Edit forms with proper input types and validation
Filters for narrowing results
Bulk actions for operating on multiple records
Association management for related records

No HTML, no CSS, no JavaScript. The admin interface is complete and usable.

Epic Stack's Testing Excellence

Epic Stack's testing setup is the most comprehensive of any boilerplate:

tests/
├── e2e/                  # Playwright end-to-end tests
│   ├── auth.test.ts
│   └── dashboard.test.ts
├── integration/          # Component + API integration
│   ├── user.test.ts
│   └── settings.test.ts
├── mocks/                # MSW request mocks
│   └── handlers.ts
└── setup/
    ├── setup-test-env.ts
    └── global-setup.ts

Every feature in Epic Stack comes with tests. The testing patterns are documented and repeatable:

Unit tests with Vitest for utility functions
Integration tests with Testing Library for components
E2E tests with Playwright for user flows
API mocking with MSW for reliable, fast tests
Database seeding for test fixtures

Kent C. Dodds (the creator) literally wrote the book on testing JavaScript. Epic Stack is his reference implementation.

Architecture Philosophy

Avo (Rails): Convention-Over-Configuration

Rails decides for you:

File names determine class names: app/models/user.rb → User
Table names from model names: User → users
URL patterns from controller names: UsersController → /users
View locations from actions: users#index → app/views/users/index.html.erb

Advantages: Less decision fatigue, faster initial development, consistent codebases across teams.

Disadvantages: Fighting conventions is painful, "magic" behavior can be hard to debug, framework coupling is deep.

Epic Stack (Remix): Web Standards

Epic Stack uses web platform APIs whenever possible:

<form> elements for mutations (not client-side state)
Request/Response objects for server communication
HTTP Cache-Control headers for caching
Set-Cookie for session management
Progressive enhancement (works without JavaScript)

// Remix loader — standard Request/Response
export async function loader({ request }: LoaderFunctionArgs) {
  const user = await requireUser(request);
  return json({ user }, {
    headers: {
      "Cache-Control": "private, max-age=60",
    },
  });
}

// Remix action — standard form submission
export async function action({ request }: ActionFunctionArgs) {
  const formData = await request.formData();
  const name = formData.get("name");
  // Validate, save, redirect
  return redirect("/dashboard");
}

Advantages: Transferable skills (web standards don't change), progressive enhancement (works offline), simpler mental model (HTTP, not framework abstractions).

Disadvantages: More manual work (no auto-generation), less "magic" means more code, smaller ecosystem than Next.js.

Performance

Server Performance

Metric	Avo (Rails + Puma)	Epic Stack (Remix)
Requests/sec (simple page)	~2,000-3,000	~5,000-8,000
Requests/sec (DB query)	~1,000-2,000	~3,000-5,000
Memory usage	200-400 MB	50-150 MB
Cold start	2-5s	0.5-1s
Typical TTFB	50-100ms	30-80ms

Node.js/Remix is generally faster for web request handling. Ruby is slower at raw throughput but Rails' caching (Russian doll caching, fragment caching) makes production performance competitive.

Client Performance

Epic Stack wins here significantly:

Progressive enhancement means pages work without JavaScript
Smaller client bundles (Remix ships less JS than a typical Rails + Turbo setup)
Streaming SSR sends content as it's ready, not waiting for everything

Avo's admin panels are interactive but require Turbo and Stimulus JavaScript. For admin use cases, this is fine — admins have good connections and modern browsers.

Community and Hiring

Metric	Rails/Ruby	Remix/TypeScript
Language ranking (TIOBE)	~15	TypeScript ~8
GitHub stars (framework)	56K (Rails)	30K (Remix)
Job listings	~5,000 (Rails)	~2,000 (Remix)
Stack Overflow questions	~350K (Rails)	~3,500 (Remix)
Average developer salary	High ($130K+)	High ($130K+)
New developers learning	Declining	Growing

Rails has a larger established community. Remix has a growing community with overlap from the much larger React ecosystem. TypeScript developers are easier to find than Ruby developers in 2026.

Pricing

Avo

Plan	Monthly Cost	Features
Community	$0	Basic resources, fields, CRUD
Pro	$99/month	Custom fields, actions, dashboards
Advanced	$149/month	Auth, search, multi-tenancy

Epic Stack

Plan	Cost
Open source	$0
All features	Included
Updates	Free (open source)

Epic Stack is completely free. Avo's premium features add up: over 3 years, Pro costs $3,564 and Advanced costs $5,364.

When to Choose Each

Choose Avo (Rails) If:

You're building admin panels or internal tools — Avo's auto-generation is unmatched
You know Ruby and love Rails — convention-over-configuration accelerates development
Your app is data-management heavy — CRUD operations on complex data models with relationships, filters, and bulk actions
You need background jobs natively — Sidekiq and Active Job are production-grade
You want a full-stack framework — Rails handles everything from email to WebSockets
You're building B2B SaaS where the admin experience is the product

Choose Epic Stack (Remix) If:

You're building customer-facing web applications — progressive enhancement and performance matter for end users
Testing is important — Epic Stack's testing setup is the gold standard
You value web standards — skills transfer to any web framework
You want free, forever — no licensing costs, no feature gates
You're hiring TypeScript developers — larger and growing talent pool
Progressive enhancement matters — forms that work without JS, HTTP caching, accessibility-first

The Key Insight

These aren't substitutes — they're complementary approaches for different parts of an application:

Avo excels at the internal/admin side where rapid CRUD generation saves weeks of development
Epic Stack excels at the customer-facing side where performance, accessibility, and user experience matter

Some teams use both: Rails + Avo for the admin API and data management, a JavaScript frontend for the customer-facing application. This is a valid architecture, especially for B2B SaaS where the admin experience is complex.

Compare Avo, Epic Stack, and 50+ other boilerplates on StarterPick — find the right framework for your project.

Comments