Learning Path
Your Rails Path
A structured trail from scratch to production deploy.
Computer architecture
Understanding CPU, RAM, and disk in a Ruby context.
Binary & data representation
How computers store numbers and text (ASCII/UTF-8).
Operating system basics
Processes, threads, and filesystems for developers.
Compilers & interpreters
How Ruby code is transformed into machine instructions.
Computational thinking
Decomposing complex problems into smaller tasks.
Algorithms: pseudo-code
Expressing logic without worrying about syntax.
Logic: boolean algebra
Mastering AND, OR, NOT and truth tables.
Flowcharts & decision trees
Visualizing application logic flows.
The web: request-response
The fundamental cycle of every Rails interaction.
Internet fundamentals (TCP/IP)
How data packets travel the global network.
DNS basics
How domains resolve to IP addresses globally.
HTTP/HTTPS protocols
Securing data transfer in the modern browser.
URL anatomy
Parsing protocols, domains, paths, and queries.
HTTP verb: GET
Deep dive into data retrieval and safe request methods.
HTTP verb: POST
Understanding data submission and server-side persistence.
HTTP verb: PUT
Updating existing resources by replacing their entire state.
HTTP verb: PATCH
Applying partial updates to existing application resources.
HTTP verb: DELETE
Removing resources permanently from the server database.
HTTP status codes: success (2xx)
200 OK, 201 Created, 204 No Content and when to use each.
HTTP status codes: redirection (3xx)
301, 302 redirects, SEO impact, and caching behavior.
HTTP status codes: client errors (4xx)
400, 401, 403, 404 — validation, auth, and missing resources.
HTTP status codes: server errors (5xx)
500, 503 — debugging, monitoring, and retry strategies.
Terminal basics
Navigation with cd, ls, and pwd commands.
File operations: terminal
Manipulation with touch, mkdir, and rm commands.
Reading files: cat, less, tail
Inspecting file content directly from the shell.
Development environment: macOS
Setting up Homebrew, rbenv, PostgreSQL and VS Code.
Development environment: Linux
Setting up build-essential and Ruby on Ubuntu/Debian.
Development environment: Windows (WSL2)
Configuring the Linux subsystem and VS Code bridge.
Git init & local configuration
Manually initializing repositories and identity.
Git workflow: add & commit
The standard staging and versions lifecycle.
Git remotes: push & pull
Syncing code with GitHub and origin servers.
Git branching & checkout
Creating isolated paths for features and fixes.
Git merging & conflicts
Combining work and resolving source code clashes.
GitHub pull requests
Professional code review and collaboration cycle.
DOM basics
The structure and tree-like nature of the Document Object Model.
Metadata tags
Usage of title, meta charset, and link tags for SEO.
Semantic HTML: layout
Using header, main, and footer for structural meaning.
Semantic HTML: content
Meaningful tags like article, section, and nav for accessibility.
Text formatting
Semantic usage of headings and inline text elements.
Links and images
Implementing hyperlinks, images, and accessible alt text.
Multimedia: video & audio
Embedding native browser media players with HTML tags.
Lists (ol/ul)
Creating ordered and unordered lists for data structure.
Tables
Basic data layout with table, row, and cell elements.
HTML forms: inputs
Text, email, password, and number input implementations.
HTML forms: selections
Implementing checkboxes, radio buttons, and select menus.
HTML forms: labels & fieldsets
Improving accessibility and organization with label tags.
CSS selectors
Targeting elements with classes, IDs, and tag names.
CSS box model
Mastering margin, border, padding, and content flow.
CSS colors: HSL & hex
Using Hex, RGB, and HSL values for visual design.
CSS units (px, rem, em)
Difference between absolute and relative sizing units.
CSS layouts (block vs inline)
Understanding the flow of block and inline elements.
CSS flexbox: alignment
Managing item alignment with justify and items properties.
CSS flexbox: direction
Directional layout control with flex-direction basics.
Positioning (relative/absolute)
Static, Relative, Absolute, and Fixed positioning types.
Media queries & responsive
Implementing basic responsive design breakpoints.
CSS specificity
How the browser determines which styles override others.
Ruby: programmer happiness
Understanding the philosophy behind Ruby syntax.
Ruby variables & assignment
Local and instance (@) variable scopes.
Ruby symbols vs strings
Memory efficiency and immutability differences.
Ruby data: numbers & booleans
Working with Integers, Floats, and truthiness.
Ruby methods & returns
Syntax for def, parameters, and implicit returns.
Ruby logic: standard checks
Controlling flow with if, else, and unless.
Ruby logic: pattern matching (case/in)
Checking a value's shape and taking arrays and hashes apart with case/in.
Ruby collections: arrays
Collection basics: creation, indexing, and push/pop.
Ruby collections: hashes
Key-value pair data structures and literals.
Ruby enumerable: each
The core iterator for looping through collections.
Ruby enumerable: map
Transforming data arrays into new collection states.
Ruby enumerable: select
Filtering data based on specific logical conditions.
Ruby blocks (do..end)
Passing chunks of code to methods via blocks.
The Rails way
Convention over Configuration and productivity.
Rails MVC overview
Setup of Models, Views, and Controllers pattern.
Rails CLI: rails new
Generating full application directory structures.
Rails server & Puma
Running the default web server for development.
Rails console (IRB)
Interacting with the application via command line.
Rails routes: basics
Defining the entry points of your web application.
ActiveRecord: model introduction
Models as a bridge between Ruby and SQL.
ActiveRecord: creating records
Writing data to the database securely.
ActiveRecord: finding records
Retrieving data using .find, .find_by, and .all.
ActiveRecord: migrations
Versioning your database schema changes over time.
ActionController: actions
Handling index, show, new, and create basics.
Controller params & security
Securely accessing and filtering form data.
ActionView: templates (ERB)
Rendering dynamic HTML with Embedded Ruby tags.
ActionView: layouts & yield
Understanding global wrappers and content yield.
ActionView: partials
Extracting reusable UI components.
Rails helpers: link_to
Generating accessible anchor tags for navigation.
Rails helpers: image_tag
Rendering optimized images via the asset pipeline.
Rails forms: form_with
The unified interface for creating web forms.
Folder structure: app/assets
Where CSS, JS, and images live in a Rails app.
Bundler & Gemfile
Managing external library dependencies and versions.
Environment: dev vs test
Handling development, test, and production states.
Scaffolding: rapid prototyping
Generating full CRUD features for speed.
Capstone: personal blog
Building a full application with Rails and AI.
AI tools: introduction (Cursor & Antigravity)
Introducing agentic coding assistants for Rails.
AI principle: human in the loop
Developer accountability and the review process.
AI ethics & licensing
Understanding copyright and data privacy in LLMs.
AI safety: review before copying
Critical validation of AI-generated logic.
AI context: @Codebase & rules
Guiding LLMs with project-specific documentation and rules.
AI prompting: zero-shot Ruby
Guiding LLMs to write clean Ruby methods.
AI debugging: error resolution
Using AI to explain stack traces and suggest fixes.
AI learning: documentation
Using AI as a technical tutor for Rails 'magic'.
Interview basics: your first technical screen
HTML, CSS, Ruby and Git questions asked at internship level, and how to answer.
Live coding for beginners
Thinking out loud, small Ruby exercises, and staying calm when stuck.
Telling your story: behavioral basics
Portfolio, "why Rails", learning in public and STAR for first-timers.
Landing the internship: applications to offer
CV, LinkedIn, GitHub, the application pipeline, estágio rules and remote intern roles.
Raw SQL: select & from
Understanding the foundations of data retrieval.
SQL: where & operators
Filtering data with precision outside of ActiveRecord.
SQL: JOIN fundamentals
Combining tables: INNER, LEFT, and RIGHT joins.
SQL: grouping & aggregates
Using COUNT, SUM, AVG and GROUP BY.
SQL: indexes & performance
How B-Tree indexes speed up your Rails app.
The scientific debugging method
Forming hypotheses and isolating variables.
Debugging: binding.irb mastery
Professional inspection of live Ruby state.
Rails logs & stack traces
Reading and navigating the application output.
Browser DevTools for Rails
Inspecting Network, Console, and Elements.
ActiveSupport: extensions & time
Core data helpers and time math.
Mailers: templates & async
Generating and backgrounding emails.
Solid Cache: database caching
Database-backed caching for simple infrastructure.
Solid Queue: background jobs
Handling asynchronous tasks via database.
Job processors: Sidekiq aware
Understanding Redis-backed jobs vs Solid Queue.
Asset pipeline: Propshaft
Modern asset management for Rails 8 apps.
Hotwire: Turbo Drive & Frames
Speeding up page loads without custom JS.
Stimulus.js: actions & targets
Connecting DOM events to Stimulus logic.
Stimulus.js: clipboard controller
Building a practical copy-to-clipboard feature.
Tailwind CSS: layouts & workflow
Utility-first design directly in views.
Advanced Git: rebase & stash
Rewriting history and storing uncommitted work.
Deployment: Kamal 2 basics
Initial server orchestration setup and configuration.
Bundler: semantic versioning
Understanding gem versioning rules and updates.
GitHub: conflict resolution
Solving code clashes in pull request reviews.
Maintenance: bundle-audit
Securing apps against vulnerabilities.
Infrastructure: Redis introduction
Using in-memory data stores for fast access.
Ruby classes & initialize
Syntactic structure for building object blueprints.
Ruby inheritance
Building hierarchical class relationships and reuse.
Ruby modules: include/extend
Sharing reusable code via mixins and namespaces.
Ruby modules: prepend vs include
Understanding the method lookup chain depth.
Ruby OOP: encapsulation
Using private and protected for data protection.
Ruby closures: procs & lambdas
Working with anonymous functions and logic blocks.
Ruby exception handling
Using rescue and ensure for robust error flows.
Ruby meta: send/define_method
Dynamic method execution and generation techniques.
Ruby meta: method_missing
Handling calls to undefined methods dynamically.
Ruby regex basics
Basic string matching patterns and expressions.
Ruby symbols: hash keys
Why symbols are preferred for hash performance.
Ruby enumerable: find/any/all
Collection inspection with specialized iterators.
Ruby string interpolation
Mastering complex interpolation vs concatenation.
Ruby idioms: safe navigation
Using &. to avoid nil errors in nested calls.
Ruby idioms: memoization
Efficient value storage with the ||= pattern.
Ruby: constants (Junior)
Mastering immutable values and lexical scoping.
Ruby: garbage collection
Understanding how Ruby manages memory and objects.
Ruby: threading basics
Introduction to concurrency and the GVL limits.
ActiveRecord validations (complex)
Uniqueness, length, and conditional checks.
ActiveRecord callbacks
Understanding before_save vs after_create hooks.
ActiveRecord associations: has_one/through
Connecting models via intermediate resources.
ActiveRecord associations: polymorphic
Models that belong to multiple other model types.
ActiveRecord querying: where/find_by
Finding records with specific attribute values.
ActiveRecord querying: order/limit
Sorting and restricting database result sets.
ActiveRecord querying: pluck/select
Fetching specific columns for better speed.
ActiveRecord querying: includes & joins
Optimizing related data loading strategies.
ActiveRecord querying: N+1 detection
Identifying slow queries with logging/Bullet.
ActiveRecord migrations: indexes
Adding database indexes for faster querying.
ActiveRecord migrations: multi-table
Handling complex schema changes in one push.
ActiveRecord encryption
Securing sensitive fields at the database level.
ActiveModel: validations & naming
Adding validations to Ruby objects outside the database.
ActiveRecord: unscope/reorder
Removing default scopes and sorting on the fly.
ActiveRecord: table_name overrides
Connecting models to custom database tables.
ActiveRecord: transactions
Ensuring atomic database operations with blocks.
ActiveRecord: enums
Mapping integer columns to human-readable states.
ActiveRecord: store/JSONB
Persisting schemaless data in PostgreSQL columns.
ActiveRecord: CTE basics
Introduction to Common Table Expressions in Active Record.
Strong parameters: expect
Security via strict whitelisting in Rails 8.
Controller filters & concerns
Using before_action and shared controller logic.
Namespaced controllers
Organizing logic for admin areas or APIs.
Nested resource routing
Mapping relationships directly to URL paths.
Handling multi-format responses
Responding to HTML and JSON in one action.
API development: Jbuilder
Generating structured JSON responses cleanly.
Authentication: Rails 8
Implementing security with built-in generators.
Authorization: Pundit
Managing user permissions with Policy files.
Layout namespacing
Different themes for different app sections.
ActionController: rescue_from
Global error handling patterns in controllers.
Testing culture: RGR cycle
Mastering Red-Green-Refactor workflows.
Minitest: model & assertions
Ensuring business logic accuracy at core.
RSpec: describe/context/it
Descriptive testing syntax for Ruby apps.
RSpec matchers: expect
Equality, inclusion, and validity match mastery.
Test data: fixtures vs factories
Dynamic object generation for flexible testing.
System testing: Capybara
Simulating user interactions in a browser.
Integration testing: requests
Verifying controller and view interactions.
Testing: WebMock & VCR
Stubbing and recording network requests securely.
Testing: mocking vs stubbing
Mastering test doubles for isolated unit tests.
Testing: shared examples
Reducing RSpec duplication with reusable specs.
Testing: parallel tests
Speeding up CI pipelines by running tests in sync.
AI tools: Claude & Gemini
Comparing reasoning and context for large tasks.
AI tools: professional (Cursor & Gemini)
Advanced agentic pair programming for Rails.
AI: refactoring & extraction
Using AI to extract Services and Query objects.
AI: SQL plan & optimization
Using LLMs to identify slow query execution plans.
AI: commit message & documentation generation
Automating professional PR descriptions.
AI security: secret detection
Scanning code for hardcoded credentials.
AI learning: testing comparison
Comparing RSpec vs Minitest via AI tutoring.
AI: sentiment analysis logic
Using LLMs to classify feedback tone.
Gitflow: feature branches
Professional branch management strategies.
Code reviews: principles
Giving and receiving professional feedback.
Agile: sprints & story points
Estimating and delivering engineering tasks.
Rails engines overview
Isolation of features into modular subsystems.
Security: SQLi, CSRF & XSS
Preventing common web vulnerabilities.
Capstone: Task Tracker Pro
Building a fully tested app with RSpec and AI.
Junior Rails interview questions
MVC, ActiveRecord, validations, REST, basic SQL and N+1: what juniors get asked.
Live coding and take-home projects
Build a small Rails feature under time and deliver a take-home with tests and README.
Behavioral interviews for juniors
Teamwork stories, receiving feedback, code review culture and remote communication.
Negotiating your first developer offer
Salary research in USD and BRL, CLT vs PJ, benefits, saying no and accepting well.
Service objects: idempotency
Ensuring business logic can safely run multiple times.
Form objects: complex logic
Handling multi-model persistence and validation.
Query objects: materialized
Isolating complex filters and performance tuning.
The logic layer: Dry-RB
Using dry-validation and dry-monads for resilience.
Pattern: outbox pattern
Ensuring database and message queue consistency.
Pattern: idempotency keys
Preventing duplicate actions in distributed systems.
Advanced SQL: CTE mastery
Recursive and common table expression strategies.
SQL: window functions for BI
Complex data analysis directly in the database.
Database indexing: partial indexes
Optimizing indexes for specific data subsets.
Database: GIN indexes & JSONB
High-performance schemaless search in Postgres.
Solid Cache: database internals
Understanding how indexing makes the database cache fast.
Solid Queue: job architecture
Managing priorities and concurrency with tables.
Solid Cable: scaling WebSockets
High-performance real-time updates without Redis.
Idempotent background jobs
Designing jobs that are safe to retry infinitely.
Background jobs: ActiveJob
Architecture for asynchronous task processing.
Solid Queue: database-backed
Configuring database-backed job queues for Rails.
Solid Queue: priorities
Numeric priorities and concurrency control mastery.
ActionCable: custom channels
Building real-time Pub/Sub patterns for apps.
Solid Cable: scale
Replacing Redis for high-performance WebSockets.
API: fast serialization
High-performance JSON response strategies.
API: schema versioning
Managing breaking changes for external clients.
Rails: custom middleware
Injecting logic into the Rack processing stack.
Rails: Rack architecture
Understanding the Ruby web server interface.
ActiveStorage: variants
On-the-fly image processing and cloud storage.
Hotwire: advanced Turbo Frames
Building partial UI updates with frame logic.
Turbo Streams: WebSockets
Real-time UI delivery via broadcast updates.
Turbo Streams: HTTP
Delivering dynamic partials via standard responses.
Turbo Streams: security
Scoping real-time broadcasts to specific users.
StimulusJS: lifecycle
Mastering connect/disconnect and initialization.
StimulusJS: values/classes
Managing controller state via the DOM storage.
Hotwire: custom Stimulus
Building reusable JS components for unique UI.
ActionText: Trix
Integrating rich-text editing into Rails forms.
Accessible modals
Building Hotwire-powered accessible dialogs.
Infinite scroll
Implementing list pagination with Turbo Frames.
Asset pipeline: Importmaps
Managing JS packages without the Node toolchain.
AI RAG architecture
Retrieval-Augmented Generation for Rails apps.
AI vector search: pgvector
Implementing semantic search with PostgreSQL.
AI: vector embeddings
Understanding data representation for search.
AI prompting: few-shot
Advanced pattern matching and transformation logic.
AI agents: autonomous
Building autonomous logic agents in Pure Ruby.
AI gems: langchainrb
Orchestrating LLMs and data tools in Rails.
AI: agentic workflows
Designing loops where AI takes autonomous actions.
AI structured data: JSON
Enforcing consistent JSON output from LLMs.
AI: fine-tuning basics
Specializing models for specific domain logic.
AI: prompt architectures
Building complex chains and multi-step reasoning.
AI: quantization
Running LLMs efficiently on limited hardware.
AI security: injection
Mitigating prompt injection risks in application.
Docker mastery: custom
Building optimized Dockerfiles for production.
Docker Compose
Orchestrating multi-service local environments.
Kamal 2 mastery
Multi-app production server configurations.
CI/CD: GitHub Actions
Automated test and deploy pipelines for scale.
DevOps: Kubernetes basics
Introduction to container orchestration at scale.
DevOps: blue-green deploy
Safe production releases with zero downtime.
DevOps: log aggregation
Centralizing logs from multi-server clusters.
DevOps: distributed tracing
Tracking requests across micro-services logic.
DevOps: SSL automation
Handling cert renewal with Let's Encrypt.
Scaling: horizontal Puma
Configuring worker clusters for high traffic.
Observability: APM
Monitoring metrics with New Relic or Skylight.
Observability: Sentry
Error tracking and incident response strategies.
Security audits: OWASP
Mitigating top web application security risks.
Security audits: Brakeman
Static security analysis for Rails source code.
Security: rack-attack
Rate limiting and request filtering strategies.
Security: advanced Rack Attack
Throttling and blocking malicious web requests.
Security: CSP
Implementing Content Security Policy headers.
Security: HSTS
Enforcing secure HTTPS connections for all users.
Security: credentials
Managing encrypted secrets for cloud services.
Testing mastery: matchers
Building shared examples and custom assertions.
Testing: in-memory database
Optimizing test speed with SQLite in-memory.
Testing: mutation testing
Verifying test quality by modifying source code.
Integrations: WebMock/VCR
Mastering external network stubbing at scale.
Soft skills: tech debt
Communicating debt trade-offs to stakeholders.
Mentorship: junior pairing
Professional techniques for growth and pairing.
Agile: feature grooming
Leading collaborative technical grooming sessions.
Ownership: end-to-end
Mastering the lifecycle of independent features.
Leader: base health metrics
Measuring code coverage and maintainability.
Leader: tech debt management
Prioritizing refactoring in a product roadmap.
Leader: ADR process
Documenting architectural decisions for history.
Leader: RFC process
Driving team consensus on technical changes.
Mid-level Rails interview questions
Background jobs, caching, transactions, security, testing strategy and performance.
Live coding: design and refactor sessions
Pair-programming interviews, refactoring legacy code live and explaining trade-offs.
Behavioral interviews: ownership and impact
Quantifying impact, handling conflict, mentoring juniors and ownership stories.
Leveling up: offers, titles and career moves
Leveling frameworks, equity basics, counteroffers, promotion versus switching companies.
System design strategy
Monolith vs Microservices architectural trade-offs.
Architecture: DDD mastery
Implementing Domain-Driven Design at scale.
Architecture: event-sourcing
Building data-consistent systems with CQRS and events.
Architecture: SOA strategy
Service-Oriented Architecture for large organizations.
Architecture: private engines
Managing private Rails Engines and internal Gems.
Architecture: multi-tenant
Row-level vs Schema-level SaaS design patterns.
Architecture: repository pattern
Decoupling data access from domain business logic.
Architecture: multi-region database
Managing consistency across global clusters.
System Design: CAP theorem
Consistency, Availability, and Partition Tolerance.
System Design: PACELC theorem
Trade-offs between latency and consistency.
System Design: gossip protocols
Decentralized state sharing in large clusters.
System Design: consistent hashing
Strategies for distributing load across caches.
System Design: rate limiting algorithms
Token bucket vs Sliding window strategies.
Systemic bottlenecks
Identifying and resolving architectural plateaus.
Multi-database architecture
Splitting read/write traffic across different DBs.
Database architecture: replicas
Configuring read-only replicas for horizontal scale.
Database architecture: role-switch
Automatic routing based on HTTP verb and session.
Database sharding: horizontal
Distributing data nodes across physical servers.
Vertical sharding
Moving high-volume tables to dedicated databases.
Database: materialized views
Precomputing complex query results for speed.
Database: logical replication
Streaming data changes between different database types.
Database: change data capture (CDC)
Reacting to database changes in real-time.
Database: multi-region strategy
Latency optimization for global users.
Database: CockroachDB basics
Distributed SQL databases vs standard Postgres.
Migrations at scale: gh-ost
Zero-downtime alterations for million-row tables.
Migrations: composite keys
Advanced database schema versioning techniques.
Infrastructure: Kamal 2
Production bare-metal server orchestration mastery.
Kamal proxy: Thruster
Puma acceleration with modern proxy middleware.
Kamal proxy: multi-app
Managing multiple apps on one server with proxy.
Zero-downtime deploys
Implementing seamless production transitions.
Load balancing: Kamal
Distributing traffic across metal clusters safely.
System Design: load balancing layer 7
Advanced request routing based on content.
System Design: service mesh architecture
Managing communication with Istio or Linkerd.
Infrastructure: global CDN
Edge delivery for assets and dynamic content.
Infrastructure: edge computing
Running logic closer to the end user.
Infrastructure: disaster recovery
Planning for total region failure and recovery.
Infrastructure: chaos engineering
Resilience testing via intentional failures.
Operations: system health
Monitoring SLIs and SLOs for critical uptime.
Engineering: SLIs/SLOs
Implementing data-driven reliability metrics.
Operations: cost optimization
Reducing cloud and bare-metal server bills.
Zero-downtime Rails upgrades
Strategies for dual-booting and safe migrations.
Large scale migrations: gh-ost
Online schema changes for million-row tables.
Decommissioning legacy systems
Safe patterns for killing old features/services.
Product-engineering alignment
Connecting tech decisions to ARR, Retention, and LTV.
Technical strategy (2-5 years)
Planning long-term platform evolution roadmap.
Org design: team topologies
Structuring stream-aligned teams for speed.
Stakeholder negotiation
Managing executive expectations on tech debt.
Compliance: the regulatory landscape
Which regimes bind you, what each one asks for, where they overlap.
Compliance: GDPR deep dive
Handling the Right to be Forgotten at scale.
Compliance: LGPD deep dive
Brazilian data protection, the ANPD, and its own legal bases.
Compliance: HIPAA deep dive
Protected health information, business associates, and the Security Rule.
Compliance: the EU AI Act
Risk tiers, obligations by role, and what they demand of a Rails app.
Compliance: ISO 27001
Global standards for info security management.
Compliance: SOC 2 Type II
Ensuring deep data privacy compliance.
Future: post-quantum cryptography
Harvest-now-decrypt-later, the new standards, and what to migrate first.
Future: web3 trade-offs
What a blockchain gives you that a database cannot, and what it costs.
Future: edge database
Latency physics, where writes must live, and when a CDN is the real answer.
Capstone: global Rails
Designing a high-concurrency global architecture.
AI management system: ISO 42001
Implementing international AI standards in Rails.
AI ethics: fairness, transparency, accountability
Fairness, transparency and accountability duties for AI.
AI risk: threat modeling
Identifying autonomous agent vulnerabilities.
The Solid Stack strategy
Consolidating infrastructure with Rails 8 primitives.
Ruby: concurrency
Mastering Ractors and the Guilds model.
Ruby: GVL deep dive
Understanding the Global VM Lock for high-scale apps.
Ruby: memory & GC mastery
Optimizing memory usage and garbage collection tuning.
Rails core contributions
Giving back to the open source ecosystem.
Advanced Hotwire security
CSP, CSRF, prefetch, morphing, and what a broadcast renders without.
GraphQL vs REST strategy
High-level API architectural decisions at scale.
Performance: O-notation
Mathematical analysis of scaling algorithms.
Testing: benchmarking
Defining performance standards for the team.
Senior and staff interview questions
Architecture, scaling, observability, trade-off reasoning and incident stories.
System design interviews for Rails engineers
Whiteboard design, capacity estimation and data modeling at scale, answered in Rails terms.
Leadership interviews
Hiring, org design, influencing without authority and executive communication.
Senior offers and beyond
Total compensation, equity, contractor versus employee abroad, consulting, hiring others.