Vox

Leitura de 11 min

Estimating Sandwiches: Why the Gut Doesn’t Work, and How Small Is Better

Summary

This episode uses the analogy of estimating the time to make 100 sandwiches to illustrate the fundamental flaws of relying on gut instinct for estimation. The host, Jonathan Cottrell, demonstrates how our intuition dramatically underestimates such tasks because we fail to account for the cumulative time of individual steps and the overhead introduced by scale.

The discussion reveals that even for a familiar task like making a sandwich, gut estimates are wildly inaccurate. This inaccuracy is magnified when estimating complex, novel software projects. The episode breaks down why scale introduces inefficiencies—such as needing more ingredients, more counter space, and longer travel distances—which are analogous to the infrastructure and management overhead that occurs when scaling software applications.

The core lesson is a practical guideline for improvement: estimate smaller things. By breaking down large projects into the smallest possible components and only estimating items where you have high confidence, you limit the room for error. This methodical approach contrasts sharply with the unreliable ‘gut feeling’ method, providing a more reliable foundation for project planning and management.

Recommendations

Tools

  • Digital Ocean — Sponsored segment: Described as simple cloud hosting built for developers, allowing deployment of an SSD cloud server in 55 seconds. A discount code ‘developert’ is offered for $10 off.

Topic Timeline

  • 00:00:00 — Introduction to estimation and the sandwich analogy — Jonathan Cottrell introduces the episode’s topic: estimation. He poses an interactive question to the listener: estimate how long it would take to make 100 sandwiches using only gut instinct. This sets up the central analogy for exploring why intuitive estimation fails.
  • 00:01:10 — Analyzing the flawed gut estimation process — The host analyzes the listener’s likely thought process: multiplying the time for one sandwich (3-5 minutes) by 100. He points out that many people’s gut estimates (1-2 hours) are ludicrously low compared to this logical multiplication (5+ hours). This highlights the disconnect between our intuitive sense of ease and the reality of cumulative effort.
  • 00:02:49 — Applying the lesson to software estimation — Cottrell makes the crucial connection: if we are this wrong about estimating a familiar task like making sandwiches, how wrong must we be when using our gut to estimate novel software projects? He emphasizes that estimation becomes exponentially more difficult when the work involves things we’ve never built before.
  • 00:03:32 — How scale introduces overhead and complexity — The discussion expands to how scaling from 1 to 100 sandwiches introduces overhead—needing multiple ingredients, more space, and longer travel distances—which slows down the per-unit process. This is directly compared to software scaling, where increased user counts require new infrastructure and processes, creating management problems and overhead that affect initial estimates.
  • 00:07:36 — The one simple guideline for better estimation — After a sponsor break, Cottrell delivers the episode’s key actionable tip: estimate smaller things. The advice is to only estimate components where you have high confidence, as smaller items have less room for error. This methodical breakdown is presented as the fundamental way to limit mistakes in the estimation process.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2015-04-09T11:00:00Z
  • Duration: 00:08:56

References

Podcast Info

Transcript

[00:00:00] Developer T, my name is Jonathan Cottrell and today I’m talking to you about estimation

[00:00:05] and sandwiches.

[00:00:10] So what do sandwiches have to do with estimation?

[00:00:13] I bet you that’s what you’re asking me right now as you’re listening to this episode and

[00:00:20] I can tell you that on their own they have nothing to do with estimation but I want to

[00:00:24] make this an interactive episode.

[00:00:27] Take out a sheet of paper and I’ll wait for you here or you can just press pause.

[00:00:31] That way we don’t have to have an awkward silence.

[00:00:34] Once you have that sheet of paper out I want you to write down a number for me.

[00:00:39] Write down how long you think it would take you to make 100 sandwiches.

[00:00:44] Now just use your gut.

[00:00:46] Okay so once you have that written down I want you to think through this with me a little

[00:00:51] bit deeper.

[00:00:52] So how long would it take you to make one sandwich?

[00:00:56] Well we could imagine that it would take maybe three to five minutes for one sandwich.

[00:01:02] Now what process did you use to estimate how long it would take you to make 100 sandwiches?

[00:01:10] If you for example think the way that I think then you probably estimated that making 100

[00:01:17] sandwiches would take you 100 times one sandwich.

[00:01:20] So in the scenario of three minutes per sandwich you’re looking at 300 minutes.

[00:01:26] That is five hours.

[00:01:29] That may seem like a lot but if it takes you five minutes per sandwich then you’re looking

[00:01:34] at more like a full workday to make 100 sandwiches.

[00:01:38] Now a lot of people when I ask them this question they think they can make these sandwiches

[00:01:43] in one or two hours.

[00:01:45] Now that seems kind of ludicrous doesn’t it?

[00:01:48] It seems like that is absolutely crazy.

[00:01:50] But we think this way because we think about a single sandwich and we think about how easy

[00:01:55] it seems to make a single sandwich so 100 sandwiches is also easy and then we use our

[00:02:01] gut which is not very good at estimating to estimate how long will it take to make 100

[00:02:09] sandwiches.

[00:02:10] Now this isn’t a very scientific approach is it?

[00:02:12] If we were to instead sit down and break it down right down the amount of time that it

[00:02:16] takes to do each step then we might we come up with a close to correct amount of time

[00:02:22] that it would take us to make 100 sandwiches.

[00:02:24] Part of the reason for this is because we’ve all made a sandwich before most likely unless

[00:02:29] you live in a place where sandwiches are not a regular meal I for one live in a place where

[00:02:35] I have a sandwich at least once or twice a week so I’ve made a lot of sandwiches.

[00:02:40] So I know how long it takes to make one.

[00:02:43] This is not necessarily true for the work that we do on a day-to-day basis so when we’re

[00:02:49] gut just to estimate something that we already know how to do like make a sandwich if we’re

[00:02:55] that wrong about estimating sandwiches well how wrong are we about using our gut to estimate

[00:03:02] software projects that consist of things that we’ve never built before and maybe that nobody

[00:03:08] has ever built before.

[00:03:10] It’s very difficult to estimate very difficult to estimate gets even more difficult when

[00:03:16] you try to use your gut to estimate.

[00:03:19] So the moral of the story the whole point of this episode is to never use your gut for

[00:03:27] estimation now there’s also a few other things that we can talk about with this scenario

[00:03:32] of 100 sandwiches the 100 sandwich scenario gives us an idea of how scale might slow us

[00:03:38] down in our day-to-day operations.

[00:03:41] For example I might make one sandwich using a small loaf of bread and a small jar of mayonnaise

[00:03:50] but when I’m making 100 sandwiches I need multiple loaves of bread and I need multiple

[00:03:56] jars of mayonnaise.

[00:03:57] This means that I have to open multiple jars of mayonnaise and I have a lot of counter

[00:04:02] space and I have to travel longer distances in order to get all of the ingredients to

[00:04:08] the places where they need to go and unless I’ve set up some sort of conveyor belt line

[00:04:14] that I make my sandwiches on then I’m likely to take longer per sandwich to make 100 sandwiches

[00:04:22] than I would to make one sandwich.

[00:04:25] However I’m much more likely to make each sandwich faster on an average if I’m only

[00:04:32] making five sandwiches and the reason for that is because the support that I need to

[00:04:37] make five sandwiches is about the same as the support that I need to make one sandwich.

[00:04:42] I hope I haven’t lost you by talking about sandwiches so much hopefully you aren’t leaving

[00:04:47] the show to go make one right now but the same principles are true when it comes to

[00:04:53] software when we are building at scale it is very easy to need a larger infrastructure

[00:04:59] it becomes more of a management problem when we need a larger infrastructure to scale.

[00:05:05] Now ultimately that scale is important in order to support the job that we have so if

[00:05:11] you have a thousand users then your scale is different than if you have one or five

[00:05:17] or one hundred users and what you do with your code what you do with your software will

[00:05:24] change to support the new scale that you’re working at and if you think about the same

[00:05:30] way that you change when you’re making sandwiches you have to have new infrastructure you have

[00:05:35] to have new processes and you might take a little more overhead on in order to change

[00:05:40] things you might have to take on the overhead of walking a little bit further to get that

[00:05:46] extra loaf of bread you have similar overhead issues when you start scaling an application

[00:05:52] of course it is it is worth your time to optimize those things that’s why it’s important to

[00:05:57] look into scaling if you think that scaling is getting ready to be a problem for your

[00:06:02] particular application so be prepared for that scale to occur but remember that estimation

[00:06:09] is affected by all of these things and that’s what this episode is about is estimation so

[00:06:14] how do we get better at it how can we estimate better i have one tip for you today on how

[00:06:19] to estimate better but first i’m going to take a quick sponsor break and then we’ll

[00:06:23] be right back to the show today’s episode of developer t is sponsored by digital ocean

[00:06:29] digital ocean is simple cloud hosting built for developers they’re dedicated to offering

[00:06:33] the most intuitive and easy way to spin up a cloud server and in just 55 seconds you

[00:06:38] can deploy a solid state drive cloud server plans start at only five dollars per month

[00:06:44] for 512 megabytes of ram a 20 gigabyte solid state drive one cpu and a full terabyte of

[00:06:50] transfer in addition to offering simple and affordable ssd cloud hosting digital ocean

[00:06:56] is dedicated to building out a strong community and supports open source software they offer

[00:07:01] a vast collection of hosting tutorials and invite developers to submit articles and they

[00:07:06] pay 50 dollars per published piece deploy your ssd cloud server with digital ocean today

[00:07:12] by going to digital ocean.com now digital ocean has been kind enough to provide developer

[00:07:17] t listeners a discount of ten dollars when you use the code developer t so go to digital

[00:07:23] ocean.com and use the code developer t to get ten dollars off today and you’ll get up and running

[00:07:28] with your own ssd cloud server in just 55 seconds that’s digital ocean.com now let’s get back to the

[00:07:36] show i’m going to give you one very simple guideline for estimating better and that is

[00:07:43] estimate smaller things estimate smaller things don’t try to estimate the big project or multiple

[00:07:52] things only estimate the things that you have a high amount of confidence that your estimation

[00:07:58] is relatively correct when you estimate smaller things there’s a less room for error there’s less

[00:08:04] room for you to make a mistake and that is fundamentally the important part of estimation

[00:08:10] is trying to limit the number of places where you might make mistakes in that estimation process

[00:08:16] thank you so much for listening to developer t i hope you enjoyed this episode go make a sandwich

[00:08:21] today and think about estimation teach others around you how to estimate small things make sure

[00:08:29] you subscribe to developer t in whatever app that you listen to podcasts in that is the best way to

[00:08:35] make sure you don’t miss future episodes of developer t now i’m going to ask you for a big favor

[00:08:41] please go and leave a review in itunes that is the best way to help other developers just like you

[00:08:47] find developer t thanks so much for listening and until next time enjoy your tea

Visão de gráfico