I’ve spoken to quite a few product managers whose teams and companies have recently adopted the Agile Software Development framework. When we discuss Jobs-to-be-Done and thrv, they are often intrigued, but then say, “We just went Agile. Does Jobs-to-be-Done work with Agile?” The answer is yes, Jobs-to-be-Done not only can work with Agile, but they are better together. Agile helps you develop a product faster and JTBD helps you develop the right product. Together, you get the right product faster.

Agile has spread so quickly, it has taken many forms. Here’s a quick reminder of the core values from the Agile Manifesto:

Jobs to be Done (JTBD) is based on the idea that your customers are not buying your product, they are hiring it to get a job done. This is the foundation of its customer-centric product development method that helps you identify unmet customer needs and generate solutions to serve them.

Agile and JTBD address two different but equally important issues–how to build and what to build. Yet, they aim to achieve the same goal: satisfy customers.

In fact, that’s the first principle of The Agile Manifesto:

Agile enables teams to adapt to an environment where requirements and technology are rapidly changing. Jobs-to-be-Done gives teams a stable focus for their agile efforts–customer needs in the job-to-be-done, which never change. Putting the two together allows you to build rapidly developing products and services that matter to the customer. Every team needs to determine what should go into the next sprint and I think using JTBD to do it produces the best results.

What can happen if Agile is used without a solid product strategy framework and process such as JTBD? The team can succumb to two common fallacies that lead to a critical problem.

Fallacy 1

There is no need for product discovery.

Some Agile teams start with writing code, cranking out an MVP without asking “Why are we building this? How do I know it will satisfy customers?” Often, this happens because senior management defined the backlog in a separate meeting.

JTBD starts with discovery by talking directly to customers. You can confirm which features will satisfy users because you can connect them directly to stated customer needs. And if you use thrv as a developer, you can see the connection between your Task, the Feature Idea and the Customer Need it intends to serve so you always know why you’re building what you’re building.

Fallacy 2

If our sprints are tight enough and we release often enough, we don’t need feedback from customers.

It doesn’t matter how often you deploy if the features are irrelevant to customers and you don’t know if you are satisfying them. JTBD gives you a criteria with which to measure potential customer satisfaction–does the feature serve an unmet need and does it do it better than the competition?

It also provides a framework for checking in with customers once the product is built. Instead of asking, “Do you like this?” You ask “Does this reduce the time it takes to get the job done?” And instead of only tracking product usage, you can also track the value it produces for the customer–how much more accurately and faster are they getting the job done?

The Critical Problem

A poorly articulated product backlog that has a variable criteria for prioritization and is full of features that do not matter to the customer.

Without clear criteria for prioritization, opinion will win. Though an agile team decreases the cost of each release, if you’re placing bets on opinion, it may take many releases to stumble upon the right features. That cost adds up quickly. And it’s multiplied by technical debt. Every time a feature goes unused, it needs to be removed. If it’s not, it can cause side effects that get in the way of new development, making every new build take longer. The cost of building the wrong thing compounds with each deployment.

JTBD provides a clear, customer-focused criteria for prioritization. Though researching customer needs requires time up front, it helps teams avoid delays and costs down the road. Investigating the customer’s job leads to finding the right features in far fewer releases.

Even though Agile and JTBD offer a powerful partnership, there is a natural hesitancy to try to incorporate the two methodologies. Perhaps adopting agile was disruptive and the idea of adding something new is exhausting. Here are a few of the objections that come up and ways to counter them:

Objection 1: Research is slow. Building right away is fast.

You may have a colleague remind you of the following Agile principle:

“There’s no time for lengthy and costly customer research,” they’ll say. JTBD does require some upfront research, but it can be done rather quickly, especially with thrv’s help. Regardless, the cost of building the wrong thing for multiple sprints is far more expensive than implementing JTBD.

Objection 2: Research will prevent us from being nimble.

Here’s another Agile Principle:

“Conducting all sorts of research will lock us into a certain approach, and we need to be able to shift quickly,” goes the argument.

Indeed while product feature requirements may change, the job does not. Forty years ago people wanted to curate music. They still do today, but in the intervening 40 years the products have ranged from LPs to 8-tracks to tapes to CDs to MP3 players to streaming music on phones. Customers don’t want Spotify any more than they want a 50-CD changer. They want to reduce the time it takes to find the right song for the mood. The job and the needs are stable.

Customer research doesn’t set your road map in stone because you’re always looking for a better way to serve the needs, adopting new technologies as they are ready.

Research doesn’t prohibit you from learning from releases; it gives you more specific parameters about what you’re trying to learn.

And research doesn’t prevent you from being creative: instead of throwing spaghetti at the wall, you’re throwing darts at a target, the customer need. Without understanding the job-to-be-done and customer needs, you might as well wear a blindfold when throwing the darts (or the spaghetti).

This is gross.

This is nice.

Objection 3: We just figured out agile; it’ll be too hard to add something to that mix.

Ok, here’s your chance to take an Agile Principle and turn it back on your colleagues:

If you’ve just recently finished a sprint and are reviewing your efforts, this is a perfect time to bring up Jobs-to-be-Done. It’s not about scrapping what you’re currently doing to try something new; it’s an improvement to your existing methods.

There’s nothing about Jobs-to-be-Done that precludes Agile, sprints, or scrums.

So, how can you get started without too much disruption to your release cycles?

Have your product and UX team work on the JTBD research while the engineers work on the current sprint. (I do recommend that engineering participate in the research but they can spend less time on it. If you want engineers to join the research, try decreasing the number of tasks in the sprint.) Once the research is done, you can can use quantified customer needs to prioritize the backlog for the next sprint planning session.

From now on, you’ll have features on the backlog associated with customer needs. This means that when your designers are creating wireframes or your engineers are building features, they can see the customer needs they are serving. They’ll know why their work matters and better understand how to deliver customer value. This will lead to better decisions from everyone and more productive sprints.

It’s easy to assume one ideology can handle everything and introducing another will create conflict. With Agile and JTBD, the opposite is true.

If your team is using Agile and you want to know more about adding Jobs-to-be-Done, drop me a line. I’m happy to help.