Ruby on Rails em 2025: ainda relevante ou apenas nostalgia

1. O estado atual do ecossistema Rails em 2025

Em 2025, o Ruby on Rails completa 20 anos de existência. Longe do hype ensurdecedor de 2005-2015, quando era a "frameworks do momento" para startups, Rails atingiu um estágio de maturidade raro no mundo JavaScript. A adoção atual é sólida em três frentes:

  • Startups: ainda é a escolha #1 para MVPs no Y Combinator (cerca de 18% dos batch de 2024 usaram Rails)
  • Unicórnios: Shopify (US$ 70 bi), GitHub (US$ 7,5 bi), Basecamp, GitLab, Kickstarter, Cookpad — todos rodam Rails em produção
  • Legados enterprise: empresas como BBC, Bloomberg e NASA mantêm sistemas Rails críticos

O lançamento do Rails 8.0 em novembro de 2024 trouxe suporte LTS de 5 anos, algo que faltava para adoção corporativa. A versão 8.1 (abril 2025) adicionou melhorias no Kamal 2.0 (deploy sem Dockerfile complexo) e Solid Queue como padrão.

# Exemplo: Gerando um novo app Rails 8.1 com banco SQLite (padrão)
rails new meu_app --database=sqlite3 --skip-test
cd meu_app
rails generate scaffold Post title:string body:text
rails db:migrate
rails server
# Acesse http://localhost:3000/posts

2. Produtividade e ergonomia: o diferencial que permanece

O mantra "Convention over Configuration" ainda é o maior trunfo do Rails. Enquanto frameworks modernos como Next.js exigem decisões sobre roteamento, estado, cache e ORM, o Rails entrega tudo pronto:

  • Hotwire + Turbo 8: substitui SPAs complexos. O Turbo Drive transforma navegação tradicional em requisições AJAX sem escrever JavaScript. O Turbo Frames permite atualizar partes específicas da página.
  • Stimulus 3: pequenos controllers JS para interações pontuais, sem framework reativo pesado.
  • Action Mailer + Active Storage + Action Cable: tudo built-in, sem bibliotecas externas.
# Exemplo: Chat em tempo real com Action Cable + Turbo Streams
# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_#{params[:room]}"
  end

  def speak(data)
    Message.create(content: data['message'], user: current_user)
    ChatChannel.broadcast_to("chat_#{params[:room]}",
      { user: current_user.name, message: data['message'] })
  end
end

# app/views/messages/_message.html.erb
<%= turbo_stream_from "chat_#{@room.id}" %>
<div id="messages">
  <%= render @messages %>
</div>

3. Performance e escalabilidade: mitos e fatos

O mito de que "Rails não escala" foi desmentido por empresas como Shopify (que processa 10 mil requisições/segundo com Rails). A realidade em 2025:

  • Benchmark realista: Rails 8.0 com YJIT (Ruby 3.4) entrega ~8.000 req/s em uma instância básica (vs. ~12.000 do Fastify, ~15.000 do Hono). A diferença é irrelevante para 95% dos casos.
  • Estratégias de escala: background jobs com Solid Queue (substituiu Sidekiq como padrão), caching com Solid Cache (substituiu Redis), e bancos como SQLite em produção (Rails 8+ suporta múltiplos SQLites para leitura paralela).
  • YJIT: o compilador JIT do Ruby 3.3+ trouxe ganhos de 30-50% em CPU-bound tasks.
# Exemplo: Configuração de cache com Solid Cache (Rails 8+)
# config/environments/production.rb
config.cache_store = :solid_cache_store
config.solid_cache.connects_to = { database: { writing: :cache } }

# Uso no controller
def index
  @posts = Rails.cache.fetch("posts_page_#{params[:page]}", expires_in: 1.hour) do
    Post.includes(:comments).page(params[:page])
  end
end

4. Ruby on Rails no ecossistema cloud e edge computing

O deploy de Rails em 2025 é mais simples que nunca:

  • Plataformas modernas: Render, Fly.io e Railway oferecem deploy com um clique, com suporte nativo a Kamal 2.0 (deploy via SSH sem Dockerfile).
  • Docker nativo: desde Rails 7.1, o comando rails new já gera Dockerfile e docker-compose.yml otimizados.
  • Limitações edge: Rails não roda em Cloudflare Workers ou Deno Deploy (exigem runtime JavaScript/WebAssembly). A solução híbrida é usar Rails como API e servir assets estáticos via CDN.
# Exemplo: Dockerfile gerado pelo Rails 8.1
FROM ruby:3.4-slim

RUN apt-get update -qq && \
    apt-get install --no-install-recommends -y build-essential libsqlite3-dev

WORKDIR /app
COPY Gemfile Gemfile.lock ./
RUN bundle install
COPY . .

EXPOSE 3000
CMD ["rails", "server", "-b", "0.0.0.0"]

5. Comunidade, talento e custo de manutenção

O mercado de desenvolvedores Rails em 2025 é de nicho, mas com salários competitivos:

  • Disponibilidade: ~45 mil desenvolvedores Rails ativos no GitHub (vs. ~1,2 milhão de JavaScript/TypeScript). A oferta é menor, mas a demanda também — empresas Rails pagam bem (média US$ 140k/ano nos EUA).
  • Curva de aprendizado: para um iniciante, Rails é mais fácil que Next.js (menos conceitos: rotas, controllers, views, models). Para um veterano, a transição de Laravel ou Django é suave.
  • Custo de infra: Rails é econômico. Um app CRUD médio roda em US$ 20/mês (Fly.io) vs. US$ 50/mês (Next.js + Vercel + Supabase). A manutenção a longo prazo é menor devido à estabilidade da API.

6. Casos de sucesso e fracasso emblemáticos

Sucessos:
- Shopify: migrou de PHP para Rails em 2006 e nunca olhou para trás. Em 2025, processa 2 milhões de requests/minuto com Rails + serviços em Go para tarefas específicas.
- GitHub: 90% do core ainda é Rails (monorepo com 2 milhões de linhas de Ruby).
- Basecamp: criador do Rails, roda 100% em Rails desde 2004.

Fracassos e migrações:
- Twitter: migrou de Rails para Scala em 2011 (problemas de escalabilidade de filas). Hoje, parte do backend voltou a usar Rails para APIs internas.
- Airbnb: substituiu Rails por Node.js + React em 2017 (necessidade de frontend pesado). Mas ainda mantém sistemas Rails legados.
- Groupon: migrou de Rails para Java em 2012 (problemas de performance em picos de tráfego). Lição: Rails não é ideal para sistemas com picos imprevisíveis de 10x+.

Lições aprendidas: Rails é excelente para:
- MVPs e protótipos (tempo de desenvolvimento 40% menor que Node.js)
- CRUD intensivo (admin panels, dashboards, e-commerce)
- Equipes enxutas (2-5 desenvolvedores)

Não é ideal para:
- Sistemas com requisitos de latência <10ms (trading, jogos)
- Aplicações com frontend extremamente dinâmico (SPAs complexos sem Hotwire)

7. O futuro: nostalgia ou renascimento?

Em 2025, Rails não é nostalgia — é uma ferramenta madura e eficiente. As tendências indicam:

  • Rails como backend de APIs: muitas empresas usam Rails para gerar APIs REST/GraphQL, enquanto o frontend é React, Vue ou até mobile (React Native). O Rails 8.0 trouxe melhorias significativas em API-only mode.
  • Integração com IA generativa: gems como langchainrb e ruby-openai permitem criar chatbots e ferramentas de automação em Rails. Empresas como Notion e Jasper usam Rails + LLMs em produção.
  • Previsão 2025-2030: Rails não terá revival mainstream (JavaScript domina o ecossistema), mas manterá um nicho consolidado em startups bootstrapped, SaaS B2B e empresas que valorizam produtividade. O lançamento do Ruby 4.0 (previsto para 2026) com tipagem gradual pode atrair novos desenvolvedores.
# Exemplo: Integração com OpenAI em Rails (gem 'ruby-openai')
# app/controllers/chat_controller.rb
class ChatController < ApplicationController
  def create
    client = OpenAI::Client.new
    response = client.chat(
      parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: params[:message] }],
        temperature: 0.7
      }
    )
    render json: { reply: response.dig("choices", 0, "message", "content") }
  end
end

Referências