Build Robust and Production Quality Applications


The goal of this course is to take you beyond a beginner Rails developer and learn what it takes to launch real, robust and production quality applications. We assume you already have a good understanding of Ruby and Rails foundations, so this course will focus on the engineering processes, workflows and best practices of experienced developers. We take you through building a non-trivial e-commerce application, a clone of NetFlix, with full payment processing, account management, and administration capabilities. Along the way, we'll demonstrate application level design concerns and trade-offs that you'll face in real applications. During the process of building all those features, we'll show you how to use Test Driven Development (TDD) to build production-level robustness and manage complexity in a growing codebase. Towards the end, we will teach you post-launch best practices around monitoring, data backups and ongoing maintenance concerns.

Main Topics Covered

  • The complete from idea to launch process
  • The complete application feature development process
  • Team collaboration and code reviews
  • Comprehensive coverage on Test Driven Development (TDD)
  • Advanced rails topics
  • Non-trivial service integration
  • Build workflows that involve multiple sub-systems
  • Architectural choices to manage complexity
  • E-commerce and billing management
  • Post launch application concerns


Frameworks and Integrations


Detailed Syllabus


  • Ideation, wireframes, mockups, design and development
  • Build from the application core to the peripherals
  • Add features incrementally and deploy continuously

Team Collaboration

  • Feature development with Git branching
  • Github flow
  • Code reviews

Testing and Test Driven Development (TDD)

  • The rationale behind testing
  • Technical debt
  • Unit, functional, and integration tests
  • Development and test databases
  • Shoulda matchers
  • Ways to write tests
  • TDD and red / green / refactor
  • Testing with RSpec
  • Two styles of writing tests in RSpec
  • The built-in RSpec Matchers
  • Single assertion principle
  • Controller tests
  • Object generation
  • Generate fake data
  • Dealing with cardinality and boundary conditions
  • Refactor with TDD
  • Growing complexity guided by tests
  • Interactive debugging for solution discovery
  • Respond to feature changes
  • Macros
  • Shared examples
  • Feature specs
  • Capybara
  • Test doubles and method stubs
  • Feature tests with Javascript
  • Testing email sending
  • Fully integrated API tests
  • Isolated API tests
  • Message expectations
  • Mocking
  • Stubs and mocks

Building Applications

  • Seeding data
  • Search
  • Sending emails
  • Use random tokens
  • Email Service Providers
  • Custom form builders
  • Custom form builders as gems
  • Complex forms
  • Self referential associations
  • Organize cross cutting functionality with Concerns
  • Background jobs
  • Resque and Sidekiq
  • S3
  • Uploading files
  • Scheduled jobs
  • Skinny controller, fat model
  • Structural refactors
  • Separating actors
  • Securing access
  • Wrapping APIs
  • Responding to webhooks
  • Collect credit card payments
  • Checkout
  • Payment forms
  • Recurring billing
  • Handle callback events
  • Beyond MVC

Production Application Considerations

  • Secure sensitive data
  • Deploy with Procfile and Foreman
  • Unicorn
  • Staging and production environments
  • Custom deployment scripts
  • Safe guarding staging environment
  • Email filters for staging environment
  • Integrating SSL
  • Production environment monitoring
  • Handle production errors
  • Production data backup and restore


  • Build workflows that involve multiple sub-systems
  • Complex registration workflow
  • Invitation workflow
  • User life cycle management
  • Social networking
  • Taking and charging credit cards
  • Recurring billing
  • Privileges and access control
  • Account and billing management
  • Plan cancellation and lock out