Getting Real proposes design principles and processes for "agile" web application development. The book documents the philosophy of the 37signals, the development shop that built Ruby on Rails, and several highly successful and popular web-based applications for project management, collaboration, and personal organization, including BaseCamp, BackPack, and Writeboard. The philosophy emphasizes keeping focused on simplicity and quality, while avoiding the traps of feature-creep, over-documentation, and designing by committee. The book is organized into 16 chapters, following the application development cycle.

To provide a sense of the philosophy presented, below is the table of contents listing for the "meat" of the book (excluding the introduction and conclusion):

The Starting Line chapter 2

• Build Less: Underdo your competition
• What's Your Problem?: Build software for yourself
• Fund Yourself: Outside money is plan B
• Fix Time and Budget, Flex Scope: Launch on time and on budget
• Have an Enemy: Pick a fight
• It Shouldn't be a Chore: Your passion — or lack of — will shine through

Stay Lean chapter 3

• Less Mass: The leaner you are, the easier it is to change
• Lower Your Cost of Change: Stay flexible by reducing obstacles to change
• The Three Musketeers: Use a team of three for version 1.0
• Embrace Constraints: Let limitations guide you to creative solutions
• Be Yourself: Differentiate yourself from bigger companies by being personal and friendly

Priorities chapter 4

• What's the big idea?: Explicitly define the one-point vision for your app
• Ignore Details Early On: Work from large to small
• It's a Problem When It's a Problem: Don't waste time on problems you don't have yet
• Hire the Right Customers: Find the core market for your application and focus solely on them
• Scale Later: You don't have a scaling problem yet
• Make Opinionated Software: Your app should take sides

Feature Selection chapter 5

• Half, Not Half-Assed: Build half a product, not a half-ass product
• It Just Doesn't Matter: Essentials only
• Start With No: Make features work hard to be implemented
• Hidden Costs: Expose the price of new features
• Can You Handle It?: Build something you can manage
• Human Solutions: Build software for general concepts and encourage people to create their own solutions
• Forget Feature Requests: Let your customers remind you what's important
• Hold the Mayo: Ask people what they don't want

Process chapter 6

• Race to Running Software: Get something real up and running quickly
• Rinse and Repeat: Work in iterations
• From Idea to Implementation: Go from brainstorm to sketches to HTML to coding
• Avoid Preferences: Decide the little details so your customers don't have to
• "Done!": Decisions are temporary so make the call and move on
• Test in the Wild: Test your app via real world usage
• Shrink Your Time: Break it down

The Organization chapter 7

• Unity: Don't split into silos
• Alone Time: People need uninterrupted time to get things done
• Meetings Are Toxic: Don't have meetings
• Seek and Celebrate Small Victories: Release something today

Staffing chapter 8

• Hire Less and Hire Later: Add slow to go fast
• Kick the Tires: Work with prospective employees on a test-basis first
• Actions, Not Words: Judge potential tech hires on open source contributions
• Get Well Rounded Individuals: Go for quick learning generalists over ingrained specialists
• You Can't Fake Enthusiasm: Go for happy and average over frustrated and great
• Wordsmiths: Hire good writers

Interface Design chapter 9

• Interface First: Design the interface before you start programming
• Epicenter Design: Start from the core of the page and build outward
• Three State Solution: Design for regular, blank, and error states
• The Blank Slate: Set expectations with a thoughtful first-run experience
• Get Defensive: Design for when things go wrong
• Context Over Consistency: What makes sense here may not make sense there
• Copywriting is Interface Design: Every letter matters
• One Interface: Incorporate admin functions into the public interface

Code chapter 10

• Less Software: Keep your code as simple as possible
• Optimize for Happiness: Choose tools that keep your team excited and motivated
• Code Speaks: Listen when your code pushes back
• Manage Debt: Pay off your code and design "bills"
• Open Doors: Get data out into the world via RSS, APIs, etc.

Words chapter 11

• There's Nothing Functional about a Functional Spec: Don't write a functional specifications document
• Don't Do Dead Documents: Eliminate unnecessary paperwork
• Tell Me a Quick Story: Write stories, not details
• Use Real Words: Insert actual text instead of lorem ipsum
• Personify Your Product: What is your product's personality type?

Pricing and Signup chapter 12

• Free Samples: Give something away for free
• Easy On, Easy Off: Make signup and cancellation a painless process
• Silly Rabbit, Tricks are for Kids: Avoid long-term contracts, sign-up fees, etc.
• A Softer Bullet: Soften the blow of bad news with advance notice and grandfather clauses

Promotion chapter 13

• Hollywood Launch: Go from teaser to preview to launch
• A Powerful Promo Site: Build an ace promotional site that introduces people to your product
• Ride the Blog Wave: Blogging can be more effective than advertising (and it's a hell of a lot cheaper)
• Solicit Early: Get advance buzz and signups going ASAP
• Promote Through Education: Share your knowledge with the world
• Feature Food: They're hungry for it so serve it up
• Track Your Logs: Study your logs to track buzz
• Inline Upsell: Promote upgrade opportunities inside the app
• Name Hook: Give your app a name that's easy to remember

Support chapter 14

• Feel The Pain: Tear down the walls between support and development
• Zero Training: Use inline help and FAQs so your product doesn't require a manual or training
• Answer Quick: Quick turnaround time on support queries should be a top priority
• Tough Love: Be willing to say no to your customers
• In Fine Forum: Use forums or chat to let customers help each other
• Publicize Your Screwups: Get bad news out there and out of the way

Post-Launch chapter 15

• One Month Tuneup: Issue a major update 30 days after launch
• Keep the Posts Coming: Show your product is alive by keeping an ongoing product development blog post-launch
• Better, Not Beta: Don't use "beta" as a scapegoat
• All Bugs Are Not Created Equal: Prioritize your bugs (and even ignore some of them)
• Ride Out the Storm: Wait until knee-jerk reactions to changes die down before taking action
• Keep Up With the Joneses: Subscribe to news feeds about your competitors
• Beware the Bloat Monster: More mature doesn't have to mean more complicated
• Go With the Flow: Be open to new paths and changes in direction

The online version of the book is free. However you can purchase a print or pdf copy.