Getting Real Memo

Source : 'Getting Real' by Basecamp
The smarter, faster, easier way to build a successful web application.

Introduction: What is getting real ?

You don’t need tons of money or a huge team or a lengthy development cycle to build great software. Those things are the ingredients for slow, murky, changeless applications. Getting real takes the opposite approach.

Starting Lines

  • Build less: less features, less options, less people and corporate structure, less meetings & less promises
  • Focus on one problem: if you’re having this problem, it’s likely hundreds of thousands peoples too. There’s your market.
  • Fund yourself: outside money is plan B & constraints force creativity
  • Flex scope: fix time and budget, but flex scope (prioritize what’s really important, set expectations & be flexible)
  • Have an enemy: sometimes the best way to know what your app should be is to know what it shouldn’t be.

Stay Lean

  • Less mass: change must be easy and cheap. You can react and evolve, focus on the good ideas and drop the bad ones, listen and respond to your customers, integrate new technologies now instead of later.
    → Go for: just-in-time thinking, multi-tasking team members, embracing constraints, less software, less code, less features, small team size, simplicity, pared-down interfaces, open-source products, open data formats, an open culture that makes it easy to admit mistakes
  • Lower your cost of change: stay flexible by reducing obstacles to change.
  • Embrace constraints: constraints drive innovation and force focus. Instead of trying to remove them, use them to your advantage.
  • Be Yourself: differentiate yourself from bigger companies by being personal and friendly


  • What’s the Big Idea? Explicitly define the one-point vision for your app. You need to know the purpose of your product — the vision.
  • Ignore Details Early On: success isn’t the only thing you’ll find in the details. You’ll also find stagnation, disagreement, meetings, and delays.
  • 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. If you try to please everyone, you won’t please anyone.
  • Scale later: you don’t have a scaling problem yet.
  • Make opinionated software: your app should take sides

Feature Selection

  • Build half a product, not a half-ass product
  • Many things just don't matter, focus on the essentials only.
  • Say no: the secret to building half a product instead of a half-ass product is saying no.
  • 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. Don’t force conventions on people. Make your software general so everyone can find their own solution.
  • Forget feature requests, let your customers remind you what's important.
  • Ask people what they don’t want


  • Get something real up and running quickly
  • 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 (preferences are a way to avoid making tough decisions)
  • Accept that decisions are temporary: accept that mistakes will happen and realize it’s no big deal as long as you can correct them quickly.
  • Get real data & feedback: test your app via real world usage, there is no substitute for real people using your app in real ways.
  • Shrink your time: beak it down. Keep breaking down timeframes into smaller chunks. Then proceed one step at a time.

The Organization

  • Unity: don’t split into silos. While specialization has its advantages, it also creates a situation where staffers don't see the entire context of the web app anymore.
  • Alone time: people need uninterrupted time to get things done.
  • Meetings are toxic: do you really need a meeting? Meetings usually arise when a concept isn’t clear enough. If you must have a meeting, stick to these simple rules: 30 min, as few people as possible, have a clear agenda
  • Seek and celebrate small victories: the most important thing in software development is motivation and quick wins that you can celebrate are great motivators.


  • Hire less and later: there’s no need to get big early — or later.
  • Work with prospective employees on a test-basis first
  • Judge potential tech hires on open source contributions
  • Go for quick learning generalists over ingrained specialists
  • You can't fake enthusiasm: go for happy and average over frustrated and great
  • Hire good writers: clear writing leads to clear thinking

Interface Design

  • Interface first: design the interface before you start programming. A paper sketch is cheap and easy to change. Designing first keeps you flexible.
  • Epicenter design: start from the core of the page and build outward. At the start, ignore the extremities (navigation, footer, colors...), design the most important piece of content first.
  • 3 State solution: design for regular, blank, and error states
  • The blank slate: set expectations with a thoughtful first-run experience. The blank slate is your app’s first impression.
  • Get defensive: no matter how carefully you design your app, no matter how much testing you do, customers will still encounter problems. Design for when things go wrong.
  • Context hover consistency: it’s ok to be inconsistent if your design makes more sense that way. Give people just what matters.
  • Copywriting is interface design: good writing is good design. It’s a rare exception where words don’t accompany design.
  • One interface: don’t build separate screens to deal with admin functions. Instead, build these functions (i.e. edit, add, delete) into the regular application interface.


  • Less software: keep your code as simple as possible. Write just the code you need and no more.
  • Optimize for happiness: choose tools that keep your team excited and motivated
  • Manage debt: you need to recognize debt and pay it off at some point by cleaning up the hairy code or redesigning that so-so page.
  • Open doors: Give people access to their information via RSS feeds. Offer apis that let third-party developers build on to your tool. When you do, you make life more convenient for customers and expand the possibilities of what your app can do.


  • There’s nothing functional about a functional spec: these blueprint docs don’t let you evolve, change, and reassess.
  • Don’t do dead documents: prevent excess paperwork everywhere. Unless a document is actually going to morph into something real, don’t produce it.
  • Tell me a quick story: to explain a new feature or concept, write a brief story about it (better with screens & context).
  • Use real words: insert actual text instead of lorem ipsum. You need real copy to know what your app truly looks like.
  • Personify your product: think of your product as a person. What type of person do you want it to be? Keep those personality traits in mind as the product is built.

Personify & Sign up

  • Free samples: give something away for free. We want people to experience the product, the interface. Then, they’re much more likely to upgrade to one of the paying plans
  • Easy on, easy off: make signup and cancellation a painless process. Also, make sure people can get their data out if they decide to leave.
  • Avoid long-term contracts, sign-up fees, etc. Don’t find “tricky” ways to get more cash, earn it.
  • A softer bulle: need to deliver bad news like a price increase? Make it as painless as possible by giving folks plenty of advance notice.


  • Hollywood launch: go from teaser (post about the development & collect emails) to preview (behind-the-scenes, ideas and principles behind the app, golden tickets) to launch (launch your full marketing site and communication)
  • A powerful promo site: overview, features tour, manifesto, case studies, testimonial / reviews / press, forum, pricing & sign-up, blog.
  • Ride the blog wave: blogging can be more effective than advertising (and it’s cheaper)
  • Promote Through Education: share your knowledge with the world (tips and tricks, conferences, workshops, interviews, articles, books with helpful information).
  • Feature food: New or interesting features are a great way to generate buzz for your application.
  • Track your logs: you need to know who’s talking about you. Check your logs and find out where the buzz is coming from.
  • Inline upsell: promote upgrade opportunities inside the app.
  • Name hook: give your app a name that’s easy to remember.


  • 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: customers light up when you answer their questions quickly.
  • Tough love: be willing to say no to your customers. When it comes to feature requests, the customer is not always right.
  • In fine forum: use forums or chat to let customers help each other
  • Publicize your screw-ups: if something goes wrong, tell people. Be as open, honest, and transparent as possible.


  • Issue a major update 1 month after launch: a quick update shows you’re listening and reaffirms initial good feelings. It gives you something to talk about and others to blog about.
  • Keep the posts coming: show your product is alive by keeping an ongoing product development blog post-launch (faq, how-tos,tips & tricks, new features, updates, & fixes, buzz/press...)
  • Better, not beta: an interminable beta stage tells customers you’re not really committed to rolling out a finished product (private betas are fine, public betas are bullshit).
  • Prioritize your bugs: you don’t have to fix each bug instantly. If it won’t be addressed right away, explain why. Don’t seek someone to blame. Bugs just happen.
  • Ride out the storm: wait until knee-jerk reactions to changes die down before taking action.
  • Follow the competition: subscribe to news feeds about your competitors
  • Beware the complexity: more mature doesn’t have to mean more complicated.
  • Go with the flow: be open to new paths and changes in direction


Everyone can read a book and come up with an idea. Success is all about great execution. For software, that means doing a lot of things right: good writing, deliver on the promises, clean interface design, clean code, great promotion. The most important ingredient: the people involved. You need people who are passionate, who care about their craft, who take pride in their work, who sweat the details, who want to build something great and won’t settle for less. In the end, the folks on your team will make or break your project.