Scalability Rules: Principles for Scaling Web Sites, 2nd Edition

Fully updated! Fifty Powerful, Easy-to-Use Rules for Supporting Hyper Growth

“Whether you’re taking on a role as a technology leader in a new company or you simply want to make great technology decisions, Scalability Rules will be the go-to resource on your bookshelf.”

–Chad Dickerson, CTO, Etsy

Scalability Rules, Second Edition, is the easy-to-use scalability primer and reference for every architect, developer, network/software engineer, web professional, and manager. Authors Martin L. Abbott and Michael T. Fisher have helped scale hundreds of high-growth companies and thousands of systems. Drawing on their immense experience, they present 50 up-to-the-minute technical best practices for supporting hyper growth practically anywhere.

Fully updated to reflect new technical trends and experiences, this edition is even easier to read, understand, and apply. Abbott and Fisher have also added powerful “stories behind the rules”: actual experiences and case studies from CTOs and technology executives at Etsy, NASDAQ, Salesforce, Shutterfly, Chegg, Warby Parker, Twitter, and other scalability pioneers.

Architects will find powerful technology-agnostic insights for creating and evaluating designs. Developers will discover specific techniques for handling everything from databases to state. Managers will get invaluable help in setting goals, making decisions, and interacting with technical teams. Whatever your role, you’ll find practical risk/benefit guidance for setting priorities, translating plans into action, and gaining maximum scalability at minimum cost.

You’ll learn how to

• Simplify architectures and avoid “over-engineering”
• Design scale into your solution, so you can scale on a just-in-time basis
• Make the most of cloning and replication
• Separate functionality and split data sets
• Scale out, not up
• Get more out of databases without compromising scalability
• Eliminate unnecessary redirects and redundant double-checking
• Use caches and CDNs more aggressively, without unacceptable complexity
• Design for fault tolerance, graceful failure, and easy rollback
• Emphasize statelessness, and efficiently handle state when you must
• Effectively utilize asynchronous communication
• Learn from your own mistakes and others’ high-profile failures
• Prioritize your actions to get the biggest “bang for the buck”

Table of Contents

Chapter 1 Reduce the Equation
Rule 1—Don’t Overengineer the Solution
Rule 2—Design Scale into the Solution (D-I-D Process)
Rule 3—Simplify the Solution Three Times Over
Rule 4—Reduce DNS Lookups
Rule 5—Reduce Objects Where Possible
Rule 6—Use Homogeneous Networks

Chapter 2 Distribute Your Work
Rule 7—Design to Clone or Replicate Things (X Axis)
Rule 8—Design to Split Different Things (Y Axis)
Rule 9—Design to Split Similar Things (Z Axis)

Chapter 3 Design to Scale Out Horizontally
Rule 10—Design Your Solution to Scale Out, Not Just Up
Rule 11—Use Commodity Systems (Goldfish Not Thoroughbreds)
Rule 12—Scale Out Your Hosting Solution
Rule 13—Design to Leverage the Cloud

Chapter 4 Use the Right Tools
Rule 14—Use Databases Appropriately
Rule 15—Firewalls, Firewalls Everywhere!
Rule 16—Actively Use Log Files

Chapter 5 Get Out of Your Own Way
Rule 17—Don’t Check Your Work
Rule 18—Stop Redirecting Traffic
Rule 19—Relax Temporal Constraints

Chapter 6 Use Caching Aggressively
Rule 20—Leverage Content Delivery Networks
Rule 21—Use Expires Headers
Rule 22—Cache Ajax Calls
Rule 23—Leverage Page Caches
Rule 24—Utilize Application Caches
Rule 25—Make Use of Object Caches
Rule 26—Put Object Caches on Their Own “Tier”

Chapter 7 Learn from Your Mistakes
Rule 27—Learn Aggressively
Rule 28—Don’t Rely on QA to Find Mistakes
Rule 29—Failing to Design for Rollback Is Designing for Failure

Chapter 8 Database Rules
Rule 30—Remove Business Intelligence from Transaction Processing
Rule 31—Be Aware of Costly Relationships
Rule 32—Use the Right Type of Database Lock
Rule 33—Pass on Using Multiphase Commits
Rule 34—Try Not to Use Select for Update
Rule 35—Don’t Select Everything

Chapter 9 Design for Fault Tolerance and Graceful Failure
Rule 36—Design Using Fault-Isolative “Swim Lanes”
Rule 37—Never Trust Single Points of Failure
Rule 38—Avoid Putting Systems in Series
Rule 39—Ensure That You Can Wire On and Off Features

Chapter 10 Avoid or Distribute State
Rule 40—Strive for Statelessness
Rule 41—Maintain Sessions in the Browser When Possible
Rule 42—Make Use of a Distributed Cache for States

Chapter 11 Asynchronous Communication and Message Buses
Rule 43—Communicate Asynchronously as Much as Possible
Rule 44—Ensure That Your Message Bus Can Scale
Rule 45—Avoid Overcrowding Your Message Bus

Chapter 12 Miscellaneous Rules
Rule 46—Be Wary of Scaling through Third Parties
Rule 47—Purge, Archive, and Cost-Justify Storage
Rule 48—Partition Inductive, Deductive, Batch, and User Interaction (OLTP) Workloads
Rule 49—Design Your Application to Be Monitored
Rule 50—Be Competent

Chapter 13 Rule Review and Prioritization
50 Scalability Rules in Brief