Food on the Table One Year Later

Presented by: Manuel Rosso, founder of Food on the Table

Food on the Table is revolutionizing the way families buy groceries and eat at home.

Food on the Table distills complex data into a simple product. Combines what’s on sale with what’s relevant and recipes to provide meal plans.

Customer validation with Concierge MVP: hand holding occurred with the first few customers. He went and met with customers at a coffee shop, sat down and went through the whole process manually.

The first few customers really cared, but the challenges are how to get to the next 100k customers.

Ideating can develop into grandiose ideas, but it’s critical to maintain discipline. Never lose sight of where you’re going AND be able to distill it down into what needs to be built right now. For example, the big plan was to get 35k stores pulling 1.5 million sales items, but customers only care about one store. So Food on the Table made sure their first ten users shopped at the same store. This brought simplicity by removing worry about how to scale system. Also, they learned that protein drives dinner decisions. Instead of 35k stores with 1.5 million items, they had one store with five sale items. Today, they have thirteen thousand stores with four hundred thousand items.

Don’t provide all possible recipes, just the right (simple) recipes with few ingredients. Also, provide four to five recipes for specific ingredients.

Food on the Table built up the recipe database based on five recipes being available every week for sale items.

Break down learning into small steps turning it into smaller experiments. Learn first, code last. Make leaps of knowledge with customers first.

Drew Houston, CEO and Founder of Dropbox: How We Decide What to Build

Presented by Drew Houston, CEO and Founder of Dropbox

People > Process:

- Great engineers are dramatically more productive than average engineers
- Hiring fewer but better people reduces need to be great at coordination, planning, etc
- 25 person engineering team split up into smaller, loosely coupled sub-teams
- Each with own roadmap, release cycle, process, team meetings, etherpads, tests, continuous deployment, etc.

Find great people:

- In general we don’t tell people how to work- no mandatory hours, etc.
- Make the office a place that people like to be
- Pick whatever workstation, tools (no budget)
- Minimize overhead and decentralize day-to-day decisions through culture/values
- Cofounder Arash maintains “soul” of the user experience; designer Jon keeper of look and feel

Big results with small numbers of people:

- One visual designer (formerly community manager!)
- Server team of 3 manages 100+billion files, 10+ petabytes of data, etc.
- Strategy: divide and conquer, keep teams small (won’t scale forever but has for now)
- As team grows, values/culture/mission made more explicit and deliberately taught to new people


- We don’t do a lot of advance planning, but we need more than we used to
- Functions outside engineering
- People don’t know what other people are up to with a larger team
- Less information spreads by osmosis
- As we grow more leaders internally, they need to stop and plan for their teams
- For a while we were doing too many things and nothing would ship for months

Dropbox company goals:

- Modeled after Googles OKR Systems
- Yearly goals and quarterly goals
- Forms a hierarchy that is shared publicly
- Overall company goals
- Overall product goals
- Team goals (e.g. client team)
- Eventually per individual

Study how other companies grew:

- Challenge with scaling orgs is things that used to work start failing quietly
- “What are we doing? Why?”
- “Why does what I’m doing matter?”
- “What is most important”
- We try to learn from other companies

Launch fast and iterate quickly

- …unless you’re making pacemakers
- different sub-teams need different engineering tradeoffs (e.g. server core teams vs. web teams)
- Our most valuable asset: people’s trust. Years to build, seconds to lose

Brad Smith, Intuit: entrepreneurship in a large company

A conversation with Intuit CEO Brad Smith and Eric Ries: The Relevance of Entrepreneurship at Intuit. Brad had a number of really awesome lines, which unfortunately came off as a bit too rehearsed, so much so, that it made me wonder if there are many Intuit engineer that have a real opportunity to innovate as entrepreneurs. I still felt that he had a lot of good things to say, and I wish more big company CEOs would talk like this.

“Entrepreneurship is the heartbeat of the company. We have 8000 entrepreneurs: our employees.”
“Everyday we work very hard to rage against the machine. Big company culture will kill innovation” (via @jbollinger)

Corporate government can’t impose more than 3 rules
We don’t ask questions, we watch
Innovation is born out of constraint
A team must be able to be fed by two pizzas
Keep teams small and iterate quickly
We suffer a rich man’s disease. Innovation is borne out of constraints
The problem with big companies is with the managers, who are too used to playing Caesar.
As a leader, it is not the answers you have or the questions you have — asking the right questions at the right time in a startup team is the most important thing as a leader
Setup  an environment of experimentation
Ultimately what led Intuit to success was exposing their stuff to customers early
Double down on the stuff that  works
The culture of experiments beats the culture of powerpoint and articulation
The two most dangerous words in business are “sounds good”
Managers remove roadblocks
“Build just in time not just in case” - don’t build a multi-generational platform that will change the world
Create the environment, and let the small teams figure it out to attain success

For a new product, Brad considered it a big success to have two groups of customers: raging advocates and pissed off people
Big  companies put processes in the way of innovation. It’s not about  spreadsheets, and processes, and planning, but that’s what managers do.
The worst management philosophy is that of a genius with a thousand helpers. You have to hire people who are working closely with the customer to solve a problem you would never have solved.

Brad described a “reverse acquisition” where they acquire a company and put the new guy in charge. For example, the Mint entrepreneur took over a division that included Mint and Quicken.

Q: How to overcome internal resistance? internal employees feeling like they lost to a competitor that is bought.
A: If we didn’t invent it ourselves, it doesn’t mean we failed
Learn from startups or bring them onboard

“The greatest minds closest to the customer develop the great ideas”

Hire entrepreneurial engineers: engineers who are in love with the outcome of the science, NOT JUST the technical stuff. You have to find someone who loves watching and learning from customers

Horizon planning
- Existing business groups increase market share, increase word-of-mouth

Q: Do you plan to put more of Quickbooks online and what are your plans for growing to other countries?
A: Connected services companies are 60% of revenue
Desktop products aren’t growing

60/30/10 revenue distribution
60% to horizon 1 products, 30% to the teenagers, 10% to new projects

SLL Conference: Andy Wiggins, Heroku

The second part of our Startup Lessons Learned series covers the interesting story of Heroku’s “Epic Pivot” told by Andy Wiggins.

photo credit: Morgan Linton

6 weeks to build initial prototype

Idea: Filemaker Pro for the web (but with real programming tools)

Accepted to Y-Combinator

Soft-Launched with Ruby Inside community
Closed $3M VC round in Feb 2008
Still hadn’t found product/market fit
Had around 10-15k enthusiastic users at this time which represented a limited market

Product market fit is not adoration of users, peers, or adoption.
Development apps - can edit on the web, can’t scale up
Production apps- can’t edit on the web but can be used with git and scale up

Cutting out the Heroku Garden web editor which was initially the key user facing feature
O’Reilly Learning Rails told users to use the web editor at the same time they were cutting it out

Early success was distracting them from long-term vision

For them, cutting the web editor was the Epic Pivot. Cutting it out was an emotional heartache but eventually made life easier. Hard to recognize pivot because they were successful.

Turned past product into Heroku Garden and led users to use new Heroku product. Eventually killed off Heroku Garden

Ultimately led to an acquisition by Salesforce for $212 Million

Eric Ries: Stop Wasting People’s Time

At SLLConf this year, we decided to try an experiment of live blogging via The event is being simulcast to a global audience, just like last year. This is the first of a series.

Eric Ries kicked it off with an update on the Lean Startup “movement.”

Eric Ries says he’s just a figurehead, later Eric Ries referred to himself a “professional talking head”. He isn’t lean startup, we are.
We are experiencing a worldwide entrepreneurial renaissance.

Everyone turn your cell phones on! Being off the internet is irresponsible and direspectful to our ancestors who created this technology for us.

Lean Startup is global — it is no longer a Silicon Valley phenomenon. Check out Lean Startup Meetups.

We are in the process of democratizing entrepreneurship.
But, it has also been institutionalized…

  • Harvard Business School- MVP Product Fund
  • Stanford University- Lean Launchpad
  • BYU- Lean Startup Research Project


  • the Entrepreneur’s Guide to Customer Development
  • Steve Blank’s Four Steps to the Epiphany
  • (and there was another one that we missed)

Entrepreneurship is not just two guys in a garage, it is a discipline

GhostBusters is one of the great entrepreneurship movies of all time
All great entrepreneurs have great stories. The movies play out like this:
Act 1) Characters& timing
Act 2) Boring stuff — the “photo montage” of people at the keyboard drinking beer
Act 3) How to divide up the spoils
This conference is about Act 2 — how does it really happen.

“A startup is a human institution designed to deliver a new product or service under conditions of extreme uncertainty.” — Eric’s definition

startup = experiment

“our future GDP growth depends on the quality and caliber of our collective imagination”

We are building companies that have fundamentally no customers and are pulled off the shelves

Frederick Winslow Taylor (March 20, 1856 – March 21, 1915) was an American mechanical engineer who sought to improve industrial efficiency.

Scientific Management:
* Study work to find the best way
* Management by exception
* Standardize work into tasks
* Compensate workers based on performance

What are we doing now that will later be revealed as myth and prejudice?

The Pivot
“better to be misunderstood than ignored”
Runway- number of pivots you still have the opportunity to make
Speed Wins

Validated learning reduces the time between pivots
Acheiving Failures = successfully exeuting on a bad plan
Why is it important to do things efficiently if we’re doing the wrong thing?

W. Edwards Deming and Taiichi Ohno- start of the Lean Revolution

Who is the customer? whose eyes matter in determining value vs. waste?

Minimize the total time through the loop
Ideas -> Build -> Code -> Measure -> Data -> Learn
see image here:

Ship it anyways and see what happens? Why spend time agruing about the details if there the chance that no one will want it.

How do we figure out what we need to learn as quickly as possible

The Toyota Way
Foundation is long term thinking -> culture that supports people to do their best work

He displayed this pyramid:

  • People
  • Culture
  • Process
  • Acountability

“We have begun to learn how to keep innovators accountable”
Use learning milestones instead of product milestones
What are the inputs to our business plan right now
better have bad news that is true than good news that we made up
“If the 10% customer adoption does not happen, everything in this business plan is irrelevant” should be a big red banner!” via @timolehes
Tune the engine -> every business has different math

Pivot or persevere? when experiments reach diminishing returns, it’s time to pivot.

“If we alllow ourselves to fail, we can train our judgement to get better over time”

Hosted Continuous Integration with CloudBees

We’ve keeping an eye out for hosted continuous integration for some time. Recently, I heard about CloudBees from John Dunham at Sauce Labs (another great cloud-hosted service which will run your Selenium tests). It seems some ofthe Hudson folk have escaped from Oracle, renamed/forked the open source project as “Jenkins” and are setting up shop with $4M from Matrix Partners with the goal of offering a platform for hosting Java apps, including the Java-based continuous integration system, Jenkins (nee Hudson).

I’ve tried it out on one Rails project I’ve tried, I’ve got specs running, but not passing and I’m not sure why yet. Here’s what I’ve figured out so far…

export rvm_path=~/.rvm
echo 'export rvm_path=~/.rvm' > ~/.rvmrc
mkdir -p ~/.rvm/src
cd ~/.rvm/src
rm -rf ./rvm/
git clone --depth 1 git://
cd rvm
rvm reload
rvm reset
rvm install ree-1.8.7
rvm use ree-1.8.7
rvm gem install bundler --no-rdoc --no-ri
rvm exec bundle install
cp config/ config/database.yml
rvm exec rake db:create:all
rvm exec rake db:migrate
rvm exec rake spec

Multi-Browser Testing w/ Capybara

On March 23rd, Blazing Cloud and Engine Yard hosted 25 Ruby enthusiasts for a Capybara and RSpec Multi-Browser testing workshop. This 2-hour session walked students through building a new Rails 3 app using RSpec and Capybara paired with Selenium for automated browser testing. A custom IDE developed by Engine Yard was used to minimize setup time and allow students to jump right into development. Blazing Cloud is excited to offer more mini-workshops in the future. Feel free to email [email protected] with any suggestions about which topics you’d like to see covered.

Download a video of the workshop (unzip, then open default.html) here

Amazon SES in 20 minutes

1) Sign into AWS account

2) Get your Account Security key, and secret key

3) add to bundle : gem ‘aws-ses’, :require => ‘aws/ses’

4) you are going to need to know that you are sandboxed - this means you can only send to - and send from emails that you verify.

here is a quick bit of code that you can drop in your rails ./script dir to verify emails and test the basics of the gem

- Begin file -

#!/usr/bin/env ruby
require File.expand_path('../../config/boot',  __FILE__)
require 'aws/ses'
class SesTool
  attr_reader :ses
  def initialize
    @ses =
      :access_key_id => 'KEY_HERE',
      :secret_access_key => 'SECRET_HERE')
  def addresses_act(name,email),email) unless email.blank?
  def send_to(email,message) :to => [email],
                        :source    => addresses_list.first,
                        :subject   => 'Subject Line',
                        :text_body => %%
  Stuff from ses_email\n
  def addresses_list
  def run(opts)
    opts = opts.dup
    case opts.shift
    when 'send' then
      puts 'send'
    when 'list' then
      puts 'list'
      p addresses_list
    when 'verify' then
    when 'delete' then
      puts 'nope'

- End File -

ruby ses_email verify [email protected]
ruby ses_email verify [email protected]
# check your email and click the verify for both
ruby ses_email send [email protected] this is a message !
# done

‘rt’ - Replace Text in Ruby for Rails 3 Upgrade, Charlie Brown

In the process of reworking a Rails 2.3.4 application into a Rails 3.0.5 application there were quite a few common changes. Most of the actual work happened in the spec testing layer where RSpec was moving from 1.3 to 2.5 and Webrat was being exchanged in favour of Capybara.

While my apprentice Anita Kuno and myself, Curtis Schofield, were working on this project, I mentioned it was recommended to me by Sarah Allen to take note of process and look at what can be automated. I’ve practiced this myself to an extent - one of the barriers I have encountered in this practice is being told that what you are doing is not necessary by people who are not career programmers. This kind of sentiment can take the wind out of ones sails.

What keeps the wind in sails is turning them to face the correct direction - I have to say that one of these directions (other than working for Captain Recruiter (it is a plug - have no doubt), and working beside Blazing Cloud and Sarah Allen’s Team) is to have an apprentice who is generally intelligent, enthusiastic and willing to explore.

It was Anita’s observation that we were doing many repetitive tasks - she asked if there was a way to automate that process. I responded by saying I had written something similar years back. I didn’t have the code anymore. However, I knew that we would be able to get some small practical tool going.

This tool is ‘rt’. A small test-driven program for asking an operator if they would like to run a regular expression on a line.

‘rt’ assumes that you are comfortable in writing (or copying) lines of YAML and are familiar with how to compose regular expressions. Regular expressions can be difficult to master or grasp the fundamentals of - many people will tell you that if you attempt to solve a problem with regular expressions - you will have 2 problems. In fact - they can be very useful and advantageous - as long as you do not expect them to be a complete substitute for a formal parser. I have used regular expressions for 10 years and they can be excellent when used in the correct place.

You will notice when running ‘rt’ that each of your regular expressions are executed on the every line in the file - matches are presented to you and you will be given a choice to accept the transformation or deny it (the ‘return/enter’ key will deny the change).

If you would like to use the actual file that we used to transform the code from RSpec 1 to 2, Webrat to Capybara and a few things around Rails 2 to rails 3. You can find this file in the repository

You will also see that we renamed an entire object ‘user’ to ‘person’ and all the plural elements of such.

Remember Tron, Users are People.

  • here is an example of taking out debugger statements
    ? !ruby/regexp /^\s+debugger\n$/m
    : ""
  • here is an example of converting - with a set of steps ‘users to people’ and ‘user to person’
    # user to person helpers
    ? !ruby/regexp /user/
    : person
    ? !ruby/regexp /User/
    : Person
    ? !ruby/regexp /users/
    : people
    ? !ruby/regexp /persons/
    : people
    ? !ruby/regexp /peoples/
    : people
  • Webrat existed in a couple different incarnations - depending on the implementer - in this one I use references to match expressions
    ? !ruby/regexp /current_dom\.css\((.+?)\)\.text\.include\?\((.+?)\)\.should be_true/
    : "page.should have_css(\1, :text => \2)"
    ? !ruby/regexp /current_dom\.at\((.+?)\)\.text\.include\?\((.+?)\)\.should == true/
    : "page.should have_css(\1, :text => \2)"

so how does one run ‘rt’?

‘rt’ can take a file or a directory - it looks for a .snoopy file at startup

This .snoopy file is you YAML collection of regular expression key value pairs

example .snoopy

# capybara migration helpers
? !ruby/regexp /request\.path/
: current_path
? !ruby/regexp /field_named/
: find_field

Any questions? email : [email protected]


More about Typus Authentication

In Device the easiest way to support an admin role is to simply add an attribute that can be used to identify administrators, which doesn’t involve any migration. So after following Lorien’s post, I set @admin_user to a Device user model and made sure it had all the required Typus attributes.
Below are the steps I followed:

1) Add admin attribute

$rails generate migration add_admin_to_user admin:boolean
class AddAdminRoleToUsers < ActiveRecord::Migration
  def self.up
    add_column :users, :admin, :boolean, :default => false
  def self.down
    remove_column :users, :admin

2) Add required Typus attributes.

class User < ActiveRecord::Base
  # Include default devise modules. Others available are:
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable,
 #typus authentication. Need this attributes to simulate typus's admin_user
  def locale
  def application(name)
  def can?(*args)
  def cannot?(*args)
  def applications

3) Set @admin_user

module Typus
  module Authentication
    module Devise
      include Base
      def authenticate
        #call devise auth
       # Set the admin user.
      def admin_user
        @admin_user = current_user if current_user && current_user.admin?

You could also use table inheritance, which is a software pattern described by Martin Fowler. The basic idea is that another field in the base database table is used to store the type of the object. But you will have to twist it around to make it work.

We have implemented this way before Francesc Esplugas’s devise support to typus.