An elementary school teacher of mine once assigned us an exercise that seemed simple on the surface, but turned out to be surprisingly complex.

It also wound up informing my entire philosophy on creating software.

The assignment’s simple-seeming description was this: “Write out each of the steps involved in making a peanut butter & jelly sandwich.”

However, its hidden complexity was hinted at with the following warning: “And make sure you write down every… single… step.”

I went home and thought about everything that went into making a PB&J sandwich, and wrote out each of the steps as clearly as I possibly could.

The day the assignment was due, we all walked into class to see an ominous pile of sandwich ingredients and utensils laid out on her desk.

She then pointed around the room and had each of us, one by one, stand up and read out loud each of the directions we’d written down.

And for each step we provided, she would advance her sandwich-making task with a punishingly literal — and, for a bunch of 4th-graders, hysterical — accuracy:

If the first step was to “get out two slices of bread”, she would tear the bag open from the middle, since she hadn’t been instructed to first undo the twist tie at the end.

Or, if another step was to “put jelly on one slice and peanut butter on the other”, she would simply place each jar on top of its own slice of bread.

Or, if we remembered to include “scoop the jelly out of the jar with a knife” but forgot to include opening the jar itself beforehand, she would stab at it with the knife until our shrieks of laughter intervened.

And on and on it went, each student’s set of directions succumbing to one omitted instruction or another, each sandwich winding up a total mess — if it was even completed at all.

Our instructions created crappy sandwiches because they failed to bridge the gap between what seemed obvious to us and what actually happened in reality.

Whereas our first set of instructions might have looked something like this…

… there were ALL KINDS of things happening in between those steps that we failed to account for:

That’s a lot to leave out!

And while kids messing up sandwich instructions by not “minding the gaps” in between isn’t a really big deal, when we in the software world have users systematically slipping through the cracks of the products we design, it definitely is.

When someone signs up for a product, they’re expressing a sense of hope — a hope that their life will be improved with that particular product in it.

When a product fails to guide its users to the “better life” that they’re hoping for, those users stop using that product. When this happens at scale, it is (ahem) bad for business.

For this reason, the more comprehensively we can bridge that gap in between — the fewer “holes” we have in our “PB&J recipe” — the more everyone benefits.

Which is why, as a designer, I am CONSTANTLY asking myself this one simple question:

Every single time someone uses software, they’re aiming to be transported from the situation they’re currently in (and don’t want to be in anymore) to a situation that they’d rather be in.

Figuring out what has to happen in getting them from one situation to the other is our principal job.

For example…

If someone is swiping around on Tinder, what happens in between that and them being on a date?

If someone has an entrepreneurial dream and is thinking about using Kickstarter to turn it into a reality, what happens in between that and them having a fully-funded project?

If someone’s simply browsing for movies on Netflix, what happens in between that and them watching one?

Regardless of whether the switching of situations is pretty straightforward (finding and watching a movie) or super complex (starting a new career), there are nearly infinite ways that we can work to ensure that our users successfully make it from one side to the other, so long as we “mind the gap” closely enough.

You can think of it like bridging a literal divide: the more comprehensively we provide assistance in making it across, the more people will survive the journey (and continue being users of our product).

Each step of that journey represents an opportunity: either an opportunity to leave it up to the user to figure things out on their own (which risks losing them), or an opportunity for us to be helpful (which builds loyalty and earns their ongoing engagement).

The “help” we offer can come in many forms. The software and its manifold features are one of them, but so are knowledge centers, blogs, podcasts, webinars, workshops, books, in-person training, video courses, and so on.

In fact, there are so many ways to be helpful that most companies have no problem coming up with areas to invest their time and energy. Instead, the problem lies in figuring out which areas are highest-leverage.

So how DO we get a read for where the best “get them from one situation to another” opportunities lie?

It involves a process that, fortunately, is as straightforward as it is effective: a little process I like to call “Break It, Break It Down.”

Here’s the playbook:

Pick two points of progress in someone’s life Break down what happens “in between” Repeat steps 1 & 2 for the gaps between each of those points

Let’s work through an example together, shall we?

I mentioned Tinder earlier, so let’s run with that:

1. Pick two points of progress in someone’s life

When kicking this exercise off, I always like to start with situations that are as “software-agnostic” as possible. This helps avoid mistaking the software we already happen to have in place with the actual progress they’re looking to achieve.

Pro tip: for those playing along at home, a great starting place is to think about a situation someone may have been in right before they pulled up your product, and what they may then go on to do immediately upon leaving it.

In Tinder’s case, the “before” and “after” scenarios are pretty straightforward. Some users may be aiming for a long-term relationship, while others may be shooting for something less involved (ahem, booty call), so let’s land somewhere in the middle and just call it “seeking out a date”:

This might seem like a pretty rudimentary “gap” to cover, but trust me — there’s a universe of opportunity to explore here.

On to step 2!

2. Break down what happens “in between”

For the first round of breaking things down, it’s ok to be pretty “high-level” — the point isn’t to be comprehensively granular (the rest of the exercise should take care of that), it’s just to get a general lay of the land.

For the purposes of this exercise in particular, let’s just make some educated guesses. The high-level “instructional PB&J” version of the dating process probably looks something like this:

For now, the important part is that it tees us up to explore what happens in between each of our “educated guesses” on the progress curve, which brings us to…

3. Repeat steps 1 & 2 for the gaps between each of THOSE points

And heeeeeere’s where it really gets interesting, because exploring the “(stuff happens in between)” for each of THESE steps can produce a whole lot of gems.

Here’s the first of the new, mini-gaps:

What has to happen between wanting to be on a date and putting yourself out there?

In a digital environment like Tinder, TONS:

That’s quite a lot — and that’s just the first gap!

If any of these mini-gaps have their own “incomplete bridges” that people fall through, the consequences could be dire: after all, if you don’t complete your profile, it’s highly unlikely you will find a match, and if you don’t find a match, you definitely won’t be going on a date!

This is why —

Hang on, I really need to emphasize this…

In order to earn your users’ ongoing engagement, it is absolutely crucial to attend to each and every one of their steps toward success, especially in the early going.

In fact, you can even break down the steps in between the IN-BETWEEN steps(!!). For example, what has to happen between “writing about yourself” and “sharing photos showing what you look like”?

Well, before you can share the photos, you have to upload them. And before you can upload them, you need to pick them out. And before you pick them out, you have to possess them in the first place.

As designers, we have a choice with each and every one of the tiny steps above: we can either stick the user with “go scrounge up whatever you have, and figure out what to do with it,” or we can instead invest in helping them have a kick-ass set of selfies that show off their best side and pull in romantic interest like a goddamned lightning rod.

It doesn’t have to be a crazy-intense effort like sending a professional photographer to take glamour shots of every new signup (though AirBnB famously achieved great results with something rather similar). It’s just that if you’re looking for inspiration for features or marketing opportunities, this is where the soil is particularly fertile.

And again, this is just one tiny, tiny leap in a series of — when you chart it all out — thousands. When you really dive into breaking it all down, it can begin to feel like this at times:

Which might seem intimidating, but you can actually look at it as exactly the opposite: as design god Charles Eames was known to say…

“The details are not the details; they make the design.”

… and this approach can take away a significant amount of the guesswork regarding which particular details are most worthy of your attention.

If you leave too many “gaps” in areas of progress in your users’ lives, you will find something else leaving: your users. This is especially true early on, when a new signup’s cost of switching is itchy-trigger-finger light.

For that reason, it is crucial to know which details to focus on and which ones to skip — if enough of your users go away, so does your business.

Anytime we decide to skip out on attending to a particular step (or mini-step, or even mini-mini-step), we are effectively saying “we will stick the user with figuring this one out on their own”:

Want to go on a date but don’t know what to wear?

“User figures it out” will never beat a Tinder guide to savvy dressing

“User figures it out” will never beat a Tinder guide to savvy dressing Want to start a project but don’t know how to attract donors?

“User figures it out” will never beat a Kickstarter ‘find your friends’ button

“User figures it out” will never beat a Kickstarter ‘find your friends’ button Want to watch a movie but don’t know what’s good right now?

“User figures it out” will never beat a Netflix recommendations algorithm

“User figures it out” is always a losing strategy when it comes to key steps in the progress curve, because it means that instead of providing assistance, we’re leaving people with one of these:

What specifically makes it a losing strategy is that there are three very likely ways in which users will then #DealWithIt:

Go somewhere else to figure it out, and then come back once they have Go somewhere else, get distracted, and wind up not coming back Decide not to #DealWithIt at all and leave the app for good

All three are sub-optimal options on our end. When they come back in scenario 1, they’re probably a little fried from the context-switching. And in scenarios 2 and 3, losing them is literally what is happening, by definition.

If we want to earn their ongoing engagement and retention, we need to take the cognitive load of “figuring things out” off their plates whenever possible.

It may sound like coddling, but they’re just one person with a very full day, and your app is, especially at first, an incomprehensibly small part of their overall lives.

However, on the other side of the equation, you’re a whole team!

Of professional software designers!

Who think about your product all day long!

Counting on your *users* to care more about your product than *you* do results in the erosion of both.

If you can’t be bothered to invest your time in facilitating progress in any given step, why on earth should they?

In order to hit the retention metrics necessary for scaling and sustaining your business, it is imperative that you smooth your users’ path forward at every opportunity.

Fortunately, however, that doesn’t mean creating a tedious interstitial stage for each step. In fact, it’s actually best when it’s just the opposite: rather than provide a plodding, Playskool-level “My First Interface” for your users, instead harness the power of technology to warp your users right past the tedium of having to deal with the task at hand at all.

Want a real-world example? Look no further than Medium.com (aka “where you are right now”).

Ever wanted to tweet a highlight of a compelling passage that you just read?

They COULD have gone the “#DealWithIt” route and left it up to the you, which would involve the clunky, user-has-to-leave-the-product workflow of:

Highlight the compelling passage

Take a screenshot

Locate the screenshot

Upload it to Twitter

Come back and copy the post’s url

Go BACK to Twitter and paste THAT

Look things over before pressing “Tweet”

And then, finally, remember to come back to Medium to pick up reading wherever you’d left off

Instead, Medium warps you through ALL OF THAT by providing this helpful little Twitter icon whenever you highlight something (whoa, this is about to get meta):

When you click on it, you’re teed up to tweet it out from the article itself!

And then you’re free to keep reading, having never even left your place.

If you’d like to try it out on your own, here’s a big, fat opportunity to share that baller design quote from earlier (it’s a real crowd-pleaser):