Trilha de Aprendizado
Seu Caminho no Rails
Uma trilha estruturada do zero ao deploy em produção.
Arquitetura de computadores
Entendendo CPU, RAM e disco no contexto Ruby.
Binário e representação de dados
Como computadores guardam números e texto.
Fundamentos de OS
Processos, threads e filesystems para devs.
Compiladores e interpretadores
Como o código Ruby é transformado em instruções.
Pensamento computacional
Decompondo problemas complexos em tarefas menores.
Algoritmos: pseudo-código
Expressando lógica sem se preocupar com sintaxe.
Lógica: álgebra booleana
Domínio de AND, OR, NOT e tabelas verdade.
Flowcharts e árvores de decisão
Visualizando fluxos de lógica de aplicação.
A web: requisição-resposta
O ciclo fundamental de cada interação Rails.
Fundamentos da internet (TCP/IP)
Como pacotes de dados viajam na rede global.
Fundamentos de DNS
Como domínios resolvem para IPs globalmente.
Protocolos HTTP/HTTPS
Segurança na transferência de dados no browser.
Anatomia da URL
Análise de protocolos, domínios, caminhos e queries.
Verbo HTTP: GET
Mergulho na recuperação de dados e métodos seguros.
Verbo HTTP: POST
Entendendo submissão de dados e persistência no servidor.
Verbo HTTP: PUT
Atualizando recursos substituindo todo o seu estado.
Verbo HTTP: PATCH
Aplicando atualizações parciais a recursos existentes.
Verbo HTTP: DELETE
Removendo recursos permanentemente do banco de dados.
Códigos de status HTTP: sucesso (2xx)
200 OK, 201 Created, 204 No Content e quando usar cada um.
Códigos de status HTTP: redirecionamento (3xx)
Redirecionamentos 301, 302, impacto SEO e cache.
Códigos de status HTTP: erros do cliente (4xx)
400, 401, 403, 404 — validação, auth e recursos ausentes.
Códigos de status HTTP: erros do servidor (5xx)
500, 503 — debugging, monitoramento e estratégias de retry.
Fundamentos de terminal
Navegação com comandos cd, ls e pwd.
Operações via terminal
Manipulação com comandos touch, mkdir e rm.
Lendo arquivos: cat, less, tail
Inspecionando arquivos via shell.
Ambiente: macOS
Setup de Homebrew, rbenv, PostgreSQL e VS Code.
Ambiente: Linux
Setup de build-essential e Ruby no Ubuntu.
Ambiente: Windows/WSL2
Configurando o subsistema Linux e ponte VS Code.
Git init & configuração local
Inicializando repositórios e identidade.
Git workflow: commit
O ciclo de vida de staging e versões.
Git remotes: push/pull
Sincronizando código com GitHub e servidores.
Git branching
Criando caminhos isolados para features.
Git merging
Combinando trabalho e resolvendo conflitos.
Pull requests
Ciclo de revisão e colaboração profissional.
Fundamentos do DOM
A estrutura em árvore do Document Object Model.
Tags de metadados
Uso de title, charset e link para SEO.
HTML semântico: layout
Usando header, main e footer para significado estrutural.
HTML semântico: conteúdo
Tags como article, section e nav para acessibilidade.
Formatação de texto
Uso semântico de títulos e elementos de texto inline.
Links e imagens
Implementando links, imagens e texto alt acessível.
Mídia: vídeo e áudio
Embutindo áudio e vídeo nativos do navegador.
Listas (ol/ul)
Criando listas ordenadas e não ordenadas para estrutura.
Tabelas
Layout de dados básico com table, row e cell.
HTML forms: inputs
Inputs de texto, email, senha e números.
HTML forms: seleção
Checkboxes, botões de rádio e menus de seleção.
HTML forms: labels
Melhorando acessibilidade com tags label e fieldset.
Seletores CSS
Alvo de elementos com classes, IDs e tags.
CSS box model
Domine margem, borda, padding e fluxo de conteúdo.
Cores CSS
Usando valores Hex, RGB e HSL para design visual.
Unidades CSS
Diferença entre unidades de tamanho absolutas e relativas.
Layouts CSS
Entendendo o fluxo de elementos block e inline.
CSS flexbox: alinhamento
Gestão de alinhamento com justify e items.
CSS flexbox: direção
Controle de layout direcional com flex-direction.
Posicionamento
Tipos de posicionamento Static, Relative, Absolute e Fixed.
Media queries
Implementando breakpoints básicos de design responsivo.
Especificidade CSS
Como o navegador determina a sobreposição de estilos.
Ruby: felicidade do dev
Entendendo a filosofia por trás da sintaxe Ruby.
Variáveis e atribuição
Escopos de variáveis locais e de instância (@).
Símbolos vs strings
Diferenças de eficiência de memória e imutabilidade.
Ruby: números & booleans
Trabalhando com números e lógica de verdade.
Métodos Ruby
Sintaxe para def, parâmetros e retornos implícitos.
Lógica Ruby
Controle de fluxo com if, else e unless.
Ruby: pattern matching (case/in)
Conferir o formato de um valor e desmontar arrays e hashes com case/in.
Arrays Ruby
Básicos de coleção: criação, índice e push/pop.
Hashes Ruby
Estruturas de dados chave-valor e literais.
Enumerable Ruby: each
O iterador core para percorrer coleções.
Enumerable Ruby: map
Transformando arrays de dados em novos estados.
Enumerable Ruby: select
Filtragem de dados baseada em condições lógicas.
Blocos Ruby (do..end)
Passando pedaços de código para métodos.
O jeito Rails
Convenção sobre Configuração e produtividade.
Visão geral do Rails MVC
Configuração do padrão Models, Views e Controllers.
Rails CLI: rails new
Gerando estruturas completas de diretórios.
Servidor Rails e Puma
Rodando o servidor web padrão para desenvolvimento.
Console Rails (IRB)
Interagindo com a aplicação via linha de comando.
Rotas Rails: fundamentos
Definindo pontos de entrada da sua aplicação web.
ActiveRecord: introdução ao model
Models como ponte entre Ruby e SQL.
ActiveRecord: criando registros
Escrevendo no banco de dados com segurança.
ActiveRecord: buscando registros
Buscando dados com .find e .all.
Migrations ActiveRecord
Versionando mudanças no esquema do banco de dados.
Controller: ações
Lidando com o básico: index, show, new e create.
Parâmetros e segurança
Acessando e filtrando dados de formulários.
ActionView: templates
Renderizando HTML dinâmico com tags Ruby.
Layouts e yield
Entendendo wrappers globais e yield.
Partials ActionView
Extraindo componentes de UI reutilizáveis.
Rails helpers: link_to
Gerando tags de âncora para navegação.
Rails helpers: image_tag
Renderizando imagens otimizadas.
Formulários Rails: form_with
A interface unificada para criar formulários web.
Estrutura: app/assets
Onde ficam assets no Rails.
Bundler e Gemfile
Gestão de dependências e versões de bibliotecas.
Ambientes: dev vs test
Lidando com os estados de dev, test e produção.
Scaffolding
Gerando CRUD completo para velocidade.
Capstone: blog pessoal
Construindo um app completo com Rails e IA.
Ferramentas de IA: introdução (Cursor & Antigravity)
Introdução a assistentes agênticos para Rails.
IA: humano no controle
Responsabilidade do dev e o processo de revisão.
Ética e licenciamento de IA
Entendendo direitos autorais e privacidade de dados.
IA: revisar antes de copiar
Validação crítica de lógica gerada por IA.
IA: contexto @Codebase
Guiando LLMs com documentação e regras do projeto.
Prompting de IA: zero-shot
Guiando LLMs para escrever métodos Ruby limpos.
IA: depuração e erros
Usando IA para explicar erros e sugerir correções.
IA: aprendendo via documentação
Usando IA como tutor para a 'mágica' do Rails.
Entrevistas: sua primeira triagem técnica
Perguntas de HTML, CSS, Ruby e Git em nível de estágio, e como responder.
Live coding para iniciantes
Pensar em voz alta, exercícios curtos em Ruby e manter a calma ao travar.
Contando sua história: básico comportamental
Portfólio, "por que Rails", aprender em público e STAR para iniciantes.
Conquistando o estágio: da candidatura à oferta
Currículo, LinkedIn, GitHub, pipeline de candidatura, regras de estágio e vagas remotas.
SQL puro: SELECT e FROM
Entendendo os fundamentos de recuperação de dados.
SQL: where e operadores
Filtragem de dados com precisão fora do ActiveRecord.
SQL: fundamentos de JOIN
Combinando tabelas: INNER, LEFT e RIGHT joins.
SQL: agregações
Usando COUNT, SUM, AVG e GROUP BY.
SQL: índices e performance
Como índices B-Tree aceleram seu app Rails.
Método científico de debug
Formando hipóteses e isolando variáveis.
Debug: domínio de binding.irb
Inspeção profissional de estado Ruby vivo.
Logs do Rails e stack traces
Lendo e navegando na saída da aplicação.
DevTools para Rails
Inspecionando Network, Console e Elements.
Extensões do ActiveSupport: datas e tempo
Helpers core e matemática do tempo.
Mailers: templates e async
Gerando e enviando emails em background.
Solid Cache: cache no banco de dados
Cache no banco de dados para infraestrutura simples.
Solid Queue: jobs em background
Lidando com tarefas assíncronas no banco.
Processadores de jobs: o papel do Sidekiq
Entendendo jobs em Redis vs Solid Queue.
Asset pipeline: Propshaft
Gestão moderna de assets no Rails 8.
Hotwire: Turbo Drive & Frames
Acelerando o app sem JS customizado.
Stimulus.js: actions & targets
Conectando eventos DOM à lógica Stimulus.
Stimulus.js: clipboard controller
Criando controle de cópia para o clipboard.
Tailwind CSS: layouts & fluxo de trabalho
Design utilitário direto nas views.
Git avançado: reescrita e guardado
Reescrevendo histórico e guardando trabalho.
Deploy: básico do Kamal 2
Configuração inicial de orquestração de servidores.
Bundler: versionamento semântico
Entendendo regras de versão de gems.
GitHub: resolução de conflitos
Resolvendo conflitos em pull requests.
Manutenção: bundle-audit
Protegendo apps contra dependências.
Infraestrutura: introdução ao Redis
Usando data stores em memória para acesso rápido.
Classes Ruby e initialize
Estrutura sintática para blueprints de objetos.
Herança Ruby
Construindo relações de herança e reaproveitamento.
Módulos Ruby
Compartilhando código via mixins e namespaces.
Modules: prepend vs include
Entendendo a cadeia de busca de métodos.
OOP Ruby: encapsulamento
Usando private e protected para proteção de dados.
Closures Ruby
Trabalhando com funções anônimas e blocos.
Gestão de exceções Ruby
Usando rescue e ensure para fluxos de erro.
Meta Ruby: send/define
Execução e geração dinâmica de métodos.
Meta Ruby: method_missing
Lidando com chamadas de métodos não definidos.
Regex Ruby
Padrões básicos de busca e expressões.
Símbolos Ruby: chaves
Por que símbolos são preferidos em hashes.
Enumerable: find/any/all
Inspeção de coleção com iteradores especiais.
Interpolação de strings
Domínio de interpolação vs concatenação.
Idiomas Ruby: safe navigation
Usando &. para evitar erros de nil.
Idiomas Ruby: memoização
Armazenamento eficiente com o padrão ||=.
Ruby: constantes (Junior)
Domínio de valores imutáveis e escopo léxico.
Ruby: coleta de lixo
Entendendo como o Ruby gere memória e objetos.
Ruby: fundamentos de Threads
Introdução à concorrência e limites do GVL.
Validações ActiveRecord avançadas
Unicidade, tamanho e verificações condicionais.
Callbacks ActiveRecord
Entendendo hooks before_save e after_create.
Associações ActiveRecord: through
Conectando models via recursos intermediários.
Associações ActiveRecord: polimórficas
Models que pertencem a múltiplos outros tipos.
Querying ActiveRecord: where
Encontrando registros com atributos específicos.
Querying ActiveRecord: order
Ordenação e restrição de resultados de busca.
Querying ActiveRecord: pluck
Buscando colunas específicas para performance.
Querying: includes e joins
Otimizando carregamento de dados relacionados.
Querying: detecção N+1
Identificando queries lentas.
Migrations ActiveRecord: índices
Adição de índices para buscas mais rápidas.
ActiveRecord: migrations multi-tabela
Mudanças complexas de esquema em um push.
Criptografia ActiveRecord
Protegendo campos sensíveis no nível do banco de dados.
ActiveModel: validações
Validações em objetos Ruby fora do banco de dados.
ActiveRecord: unscope/reorder
Removendo scopes padrão e ordenando dinamicamente.
ActiveRecord: table_name overrides
Conectando models a tabelas customizadas.
ActiveRecord: transações
Garantindo operações atômicas com blocos.
ActiveRecord: enums
Mapeando colunas inteiras para estados legíveis.
ActiveRecord: store/JSONB
Persistindo dados sem esquema em colunas JSONB.
ActiveRecord: fundamentos de CTE
Introdução a CTEs no Active Record.
Strong parameters: expect
Segurança via whitelist estrita no Rails 8.
Filtros e concerns
Usando before_action e lógica compartilhada.
Controllers com namespace
Organizando lógica para admin ou APIs.
Rotas de recursos aninhados
Mapeando relações diretamente para URLs.
Respostas multi-formato
Respondendo HTML e JSON na mesma ação.
Desenvolvimento de API: Jbuilder
Gerando respostas JSON estruturadas e limpas.
Autenticação: Rails 8
Implementando segurança com geradores nativos.
Autorização: Pundit
Gestão de permissões com arquivos Policy.
Namespacing de layout
Temas diferentes para seções diferentes do app.
ActionController: rescue_from
Padrões globais para lidar com erros.
Cultura de testes: RGR
Dominando fluxos Red-Green-Refactor.
Minitest: testes de model
Garantindo precisão da lógica de negócio.
Fundamentos de RSpec
Sintaxe descritiva para testes em Ruby.
Matchers RSpec: expect
Igualdade, inclusão e validade.
Dados de teste: FactoryBot
Geração dinâmica de objetos para testes.
Testes de sistema: Capybara
Simulando interações de usuários no navegador.
Testes de integração
Verificando controllers e views em conjunto.
Testes: WebMock e VCR
Simulando e gravando requisições.
Testes: mocking vs stubbing
Domínio de dublês para testes unitários isolados.
Testes: shared examples
Reduzindo duplicação com specs reutilizáveis.
Testes: testes em paralelo
Acelerando o CI rodando testes em paralelo.
IA: Claude e Gemini
Comparando raciocínio e contexto.
IA: profissional (Cursor e Gemini)
Pair programming agêntico avançado.
IA: refatoração e extração
Usando IA para extrair Services e Queries.
IA: plano e otimização SQL
Usando LLMs para otimizar queries.
IA: geração de mensagens de commit e documentação
Automatizando documentação de PRs.
IA: detecção de segredos
Escaneando código em busca de segredos.
IA: comparação de testes
Comparando RSpec e Minitest.
IA: análise de sentimento
Usando LLMs para classificar tom de feedback.
Gitflow: branches
Gestão profissional de branch.
Code reviews: princípios
Dando e recebendo feedback profissional.
Agile: sprints e pontos
Estimando e entregando tarefas.
Visão geral de Rails engines
Isolamento de features em módulos.
Segurança web
Prevenindo vulnerabilidades comuns.
Projeto: Task Tracker Pro
Construindo um app testado com RSpec e IA.
Perguntas de entrevista para Rails júnior
MVC, ActiveRecord, validações, REST, SQL básico e N+1: o que perguntam a júniores.
Live coding e projetos take-home
Construa uma feature Rails com tempo limitado e entregue um take-home com testes.
Entrevistas comportamentais para júniores
Histórias de equipe, receber feedback, cultura de code review e comunicação remota.
Negociando sua primeira oferta como dev
Pesquisa salarial em USD e BRL, CLT vs PJ, benefícios, dizer não e aceitar bem.
Service objects: idempotência
Lidando com execução múltipla segura de lógica.
Form objects: lógica complexa
Persistência e validação multi-model.
Query objects: materializados
Isolando filtros e tunando performance.
A camada de lógica: Dry-RB
Usando dry-validation e dry-monads para resiliência.
Padrão: outbox pattern
Garantindo consistência entre banco de dados e fila.
Padrão: chaves de idempotência
Prevenindo ações duplicadas em sistemas distribuídos.
SQL avançado: domínio de CTE
Estratégias de CTE recursiva.
SQL: funções de janela para BI
Análise de dados complexa direto no banco.
Indexação de banco de dados: índices parciais
Otimizando índices para subsets de dados.
Banco de dados: índices GIN & JSONB
Busca schemaless de alta performance.
Solid Cache: internos do banco
Como índices tornam o cache no banco de dados rápido.
Solid Queue: arquitetura de jobs
Gestão de prioridade e concorrência.
Solid Cable: escalando WebSockets
Updates em tempo real sem Redis.
Jobs em background idempotentes
Jobs seguros para retry infinito.
Background jobs: ActiveJob
Arquitetura para processamento assíncrono de tarefas.
Solid Queue: apoiado em banco de dados
Configurando filas de jobs em banco de dados.
Solid Queue: prioridades
Domínio de prioridades numéricas e controle.
ActionCable: canais personalizados
Construindo padrões Pub/Sub em tempo real.
Solid Cable: escala
Substituindo Redis para WebSockets de alta performance.
API: serialização rápida
Estratégias de resposta JSON de alta performance.
API: versionamento de schema
Gestão de breaking changes para clientes externos.
Rails: middleware personalizado
Injetando lógica no stack de processamento Rack.
Rails: arquitetura Rack
Entendendo a interface de servidor web Ruby.
ActiveStorage: variantes
Processamento de imagem e storage em nuvem.
Hotwire: Turbo Frames avançados
Criando atualizações parciais de UI com frames.
Turbo Streams: WebSockets
Entrega de UI em tempo real via broadcasts.
Turbo Streams: HTTP
Entregando partials dinâmicas via respostas padrão.
Turbo Streams: segurança
Escopando broadcasts em tempo real para usuários.
StimulusJS: ciclo de vida
Domínio de connect/disconnect e inicialização.
StimulusJS: values/classes
Gestão de estado do controller via storage do DOM.
Hotwire: Stimulus personalizado
Construindo componentes JS para UI única.
ActionText: Trix
Integrando edição de texto rico em formulários.
Modais acessíveis
Construindo diálogos acessíveis com Hotwire.
Scroll infinito
Implementando paginação de listas com Turbo Frames.
Asset pipeline: Importmaps
Gestão de JS sem ferramenta Node.
Arquitetura RAG de IA
Geração Aumentada por Recuperação para apps Rails.
Busca vetorial de IA: pgvector
Implementando busca semântica com PostgreSQL.
IA: embeddings vetoriais
Entendendo representação de dados para busca.
Prompting de IA: few-shot
Padrões avançados e lógica de transformação.
Agentes de IA: autônomos
Construindo agentes de lógica autônoma em Ruby.
Gems de IA: langchainrb
Orquestrando LLMs e ferramentas de dados no Rails.
IA: fluxos agênticos
Loops onde a IA toma ações autônomas.
Dados estruturados de IA: JSON
Forçando saída JSON consistente de LLMs.
IA: fundamentos de fine-tuning
Especializando modelos para lógica de domínio.
IA: arquiteturas de prompt
Construindo cadeias complexas e raciocínio multi-step.
IA: quantização
Rodando LLMs de forma eficiente em hardware limitado.
Segurança de IA: injeção
Mitigando riscos de injeção de prompt no app.
Docker mastery: personalizado
Construindo Dockerfiles otimizados para produção.
Docker Compose
Orquestrando ambientes locais multi-serviço.
Domínio de Kamal 2
Configurações de servidor multi-app em produção.
CI/CD: GitHub Actions
Pipelines de teste e deploy automatizados.
DevOps: fundamentos Kubernetes
Introdução à orquestração em escala.
DevOps: deploy blue-green
Releases seguras em produção sem downtime.
DevOps: agregação de logs
Centralizando logs de clusters multi-servidor.
DevOps: distributed tracing
Rastreando requisições em lógica de micro-serviços.
DevOps: automação SSL
Renovação de certificados com Let's Encrypt.
Escala: Puma horizontal
Configurando clusters de workers para tráfego.
Observabilidade: APM
Monitorando métricas com New Relic ou Skylight.
Observabilidade: Sentry
Estratégias de rastreio de erros e resposta.
Auditorias: OWASP
Mitigando os principais riscos de segurança web.
Auditorias: Brakeman
Análise estática de segurança para código Rails.
Segurança: rack-attack
Estratégias de rate limit e filtragem de req.
Segurança: Rack Attack avançado
Limitando e bloqueando requisições maliciosas.
Segurança: CSP
Implementando headers de Content Security Policy.
Segurança: HSTS
Forçando conexões HTTPS seguras para todos.
Segurança: credenciais
Gestão de segredos criptografados para nuvem.
Domínio de testes: matchers
Contextos compartilhados e asserções custom.
Testes: banco de dados em memória
Otimizando velocidade com SQLite em memória.
Testes: mutation testing
Verificando qualidade dos testes via código fonte.
Integrações: WebMock/VCR
Domínio de simulação de rede externa em escala.
Soft skills: dívida técnica
Comunicando trade-offs de dívida técnica.
Mentoria: pairing junior
Técnicas profissionais para crescimento e pairing.
Agile: refinamento de features
Liderando sessões colaborativas de refinamento.
Ownership: ponta a ponta
Domínio do ciclo de vida de features independentes.
Liderança: métricas de saúde
Medindo cobertura de código e manutenibilidade.
Liderança: gestão de dívida
Priorizando refatoração no roadmap do produto.
Liderança: processo ADR
Documentando decisões arquiteturais para o histórico.
Liderança: processo RFC
Buscando consenso do time em mudanças técnicas.
Perguntas de entrevista para Rails pleno
Jobs em background, cache, transações, segurança, estratégia de testes e performance.
Live coding: sessões de design e refatoração
Entrevistas em pair programming, refatorar código legado ao vivo e explicar trade-offs.
Entrevistas comportamentais: ownership e impacto
Quantificar impacto, lidar com conflito, mentorar júniores e histórias de ownership.
Subindo de nível: ofertas, títulos e carreira
Frameworks de nível, equity, contrapropostas, promoção versus trocar de empresa.
Estratégia de system design
Trade-offs entre Monólito e Microserviços.
Arquitetura: domínio de DDD
Implementando Domain-Driven Design em escala.
Arquitetura: event-sourcing
Sistemas consistentes com CQRS e eventos.
Arquitetura: estratégia SOA
Arquitetura Orientada a Serviços para grandes orgs.
Arquitetura: engines privadas
Gestão de Engines Rails e Gems internas.
Arquitetura: multi-tenant
Padrões de design SaaS: row-level vs schema-level.
Arquitetura: padrão repository
Desacoplando acesso a dados da lógica de domínio.
Arquitetura: banco de dados multi-região
Gestão de consistência em clusters globais.
System Design: teorema CAP
Consistência, Disponibilidade e Partição.
System Design: teorema PACELC
Trade-offs entre latência e consistência.
System Design: protocolos gossip
Compartilhamento de estado descentralizado.
System Design: hash consistente
Estratégias para distribuição de carga em caches.
System Design: algoritmos de limitação de taxa
Estratégias de balde de tokens e janela.
Gargalos sistêmicos
Identificando e resolvendo platôs arquiteturais.
Arquitetura multi-banco
Dividindo tráfego de leitura/escrita em diferentes DBs.
Arquitetura de banco de dados: réplicas
Configurando réplicas para escala horizontal.
Arquitetura de banco de dados: troca de papéis
Roteamento automático baseado em verbo e sessão.
Sharding de banco de dados: horizontal
Distribuindo nós de dados em servidores físicos.
Sharding vertical
Movendo tabelas de alto volume para DBs dedicados.
Banco de dados: views materializadas
Pré-computação de queries complexas.
Banco de dados: replicação lógica
Streaming de mudanças entre tipos de banco de dados.
Banco de dados: captura de dados de mudança (CDC)
Reagindo a mudanças no banco em tempo real.
Banco de dados: estratégia multi-região
Otimização de latência para usuários globais.
Banco de dados: fundamentos do CockroachDB
SQL distribuído vs Postgres padrão.
Migrations: gh-ost
Alterações sem downtime para tabelas massivas.
Migrations: chaves compostas
Técnicas avançadas de versionamento de esquema.
Infraestrutura: Kamal 2
Domínio de orquestração bare-metal em produção.
Kamal proxy: Thruster
Aceleração do Puma com middleware moderno.
Kamal proxy: múltiplas aplicações
Gestão de múltiplos apps via Kamal Proxy.
Deploy sem downtime
Implementando transições suaves em produção.
Load balancing: Kamal
Distribuindo tráfego em clusters de metal.
System Design: load balancing camada 7
Roteamento avançado baseado em conteúdo.
System Design: arquitetura de service mesh
Gestão de comunicação com Istio ou Linkerd.
Infraestrutura: CDN global
Entrega de assets e conteúdo dinâmico no edge.
Infraestrutura: edge computing
Rodando lógica mais próxima do usuário.
Infraestrutura: recuperação de desastres
Planejamento para falha total de região.
Infraestrutura: engenharia do caos
Testes de resiliência via falhas intencionais.
Operações: saúde do sistema
Monitoramento de SLIs e SLOs para uptime crítico.
Engenharia: SLIs/SLOs
Implementando métricas de confiabilidade.
Operações: otimização de custos
Reduzindo gastos com servidores e nuvem.
Upgrades Rails sem downtime
Estratégias de dual-booting e migração segura.
Migrations de larga escala: gh-ost
Mudanças de esquema online em tabelas massivas.
Aposentando sistemas legados
Padrões seguros para remover features legadas.
Alinhamento produto-engenharia
Ligando decisões técnicas a ARR e Retenção.
Estratégia técnica (2-5 anos)
Planejando evolução de longo prazo.
Design org: team topologies
Estruturando times para velocidade.
Negociação com stakeholders
Gestão de expectativas executivas.
Conformidade: o panorama regulatório
Quais regimes te obrigam, o que cada um exige e onde se sobrepõem.
Conformidade: GDPR a fundo
Lidando com o Direito ao Esquecimento.
Conformidade: LGPD a fundo
Proteção de dados brasileira, a ANPD e suas bases legais próprias.
Conformidade: HIPAA a fundo
Informação de saúde protegida, business associates e a Security Rule.
Conformidade: o AI Act europeu
Níveis de risco, obrigações por papel e o que exigem de uma app Rails.
Conformidade: ISO 27001
Padrões globais de gestão de segurança.
Conformidade: SOC 2 Tipo II
Garantindo conformidade profunda de dados.
Futuro: criptografia pós-quântica
Colher-agora-decifrar-depois, os novos padrões e o que migrar primeiro.
Futuro: trade-offs web3
O que uma blockchain dá que um banco não dá, e o que isso custa.
Futuro: edge database
Física da latência, onde as escritas vivem, e quando CDN é a resposta real.
Projeto: global Rails
Design de arquitetura global de alta concorrência.
Sistema de gestão de IA: ISO 42001
Implementando padrões internacionais de IA.
Ética de IA: justiça, transparência, prestação de contas
Deveres de justiça, transparência e prestação de contas em IA.
Risco de IA: threat modeling
Identificando vulnerabilidades de agentes.
Estratégia Solid Stack
Consolidando infraestrutura com primitivos do Rails 8.
Ruby: concorrência
Domínio de Ractors e o modelo Guilds.
Ruby: mergulho no GVL
Entendendo o GVL para aplicações de alta escala.
Ruby: memória e GC
Otimizando uso de memória e ajuste de GC.
Contribuições Rails core
Contribuindo de volta para o ecossistema open-source.
Segurança Hotwire avançada
CSP, CSRF, prefetch, morphing e o que um broadcast renderiza sem contexto.
GraphQL vs REST strategy
Decisões arquiteturais de API em larga escala.
Performance: notação O
Análise matemática de algoritmos em escala.
Testes: benchmarking
Definindo padrões de performance para o time.
Perguntas de entrevista para sênior e staff
Arquitetura, escala, observabilidade, raciocínio de trade-offs e histórias de incidentes.
Entrevistas de system design para devs Rails
Design no quadro, estimativa de capacidade e modelagem em escala, em termos de Rails.
Entrevistas de liderança
Contratação, desenho de organização, influência sem autoridade e comunicação executiva.
Ofertas sênior e além
Remuneração total, equity, contratado versus CLT no exterior, consultoria, contratar.