The Good Boss

The Good Boss

Rumelt's Kernel: How to Tell a Real Strategy From a List of Goals

The simple framework that exposes vague plans and forces the hard choices.

Gaurav Jain's avatar
Gaurav Jain
Nov 16, 2026
∙ Paid

It’s hard to believe it’s already November! And as we come to the end of this fiscal year, for most managers, it’s planning season again.

Over the last few weeks, I’ve read more 2027 “planning docs” than I can honestly count.

And I noticed that most of them follow the same pattern. They have a vision statement at the beginning, then there’s a list of targets, such as “grow adoption 30%”, “cut incidents in half”, “ship the new platform”, etc. And finally, there’s a roadmap in which, magically, every team’s favorite project has seemingly made the cut.

These documents - whether they’re slides, or wikis, or word documents - look like ‘strategy’ documents on the surface, but many of them lack something important.

Last week I asked a leader after he presented the strategy document a simple question: “What’s the main problem you’re trying to solve, and what are you choosing not to do because of it?”

I didn’t get a good answer.

And I want to be clear - he’s a smart manager and I respect him. But the probelm I see is that many managers aren’t aware of what a strategy is supposed to contain, so they default to the most obvious things.

As Roger Martin puts it in this video, a plan is not a strategy.

In this post, I’m going to do a deep dive into a fundamental framework called Rumelt’s Kernel that you must know if you are defining strategy in your role, no matter how big or small.

☑️ In this post

  • Part 1: Understanding Rumelt’s Kernel

    • What is Rumelt’s Kernel?

    • Why this Matters to Managers

    • Spotting Bad Strategy

    • The Three Elements of the Kernel

    • Test Your Understanding

    • Practice this Framework

  • Part 2: Applying Rumelt’s Kernel

    • Download the worksheet

    • Apply to Your Situation

    • The Kernel Rewrite Technique

  • Part 3: Going from Here

    • Common Pitfalls and How to Avoid Them

    • Final Takeaway


Subscribe to The Good Boss to get actionable strategies every Monday & Thursday, plus my ‘20 Essential Leadership Tools’ guide free when you sign up



Part 1: Understanding Rumelt’s Kernel

What is Rumelt’s Kernel?

Rumelt’s Kernel comes from one of my favorite business books, Good Strategy/Bad Strategy by Richard Rumelt, who was a professor at UCLA’s Anderson School of Management and spent decades advising companies on strategy.

This is Rumelt’s core idea:

A strategy is not a statement of ambition. It’s a response to a challenge. If you can’t name the challenge, you don’t have a strategy. What you have is a “wish”.

In the book, Rumelt calls the minimum structure of any real strategy the kernel, which is why this framework has come to be known as Rumelt’s Kernel.

The kernel has three parts: a diagnosis, a guiding policy, and a set of coherent actions. A strategy can have more than these three things. But if any one of them is missing, it isn’t a strategy.

In 2022, he followed up with another book titled The Crux, which goes deeper on the hardest part: finding the one piece of the challenge that matters most and that you can actually do something about.


Why this Matters to Managers

Many managers I coach or meet at work tell me that they’re mostly responsible for execution, not strategy.

I think that’s one of the biggest misconceptions in leadership. Here’s why I think strategy matters to managers, not just executives.

As a manager, granted, you may never write your company’s strategy. But you have a team, and every year you write your team plan, right? As part of that, you decide what projects need funding, what needs staffing, and what to push back on.

And guess what, that is nothing but strategy work. Most managers just do it without a “structure”.


Spotting Bad Strategy

Before getting into what good strategy looks like, I think it helps to know what Rumelt calls bad strategy. He calls out four signs worth paying attention to.

I think of these as the antipatterns for defining strategy, and frankly, I’ve seen every one of them in planning docs, including my own.

  1. Fluff. This is probably the most familiar one. Big or grand words that sound smart, but when you dig deeper, they say nothing. Example: “We will drive customer-centric innovation across the platform.” When you read that twice, you wonder what that even means :) The question to ask yourself is, with this strategy, what will you or your team do differently on Monday? Avoid the fluff, and make it concrete.

  2. Failure to name the challenge. As I mentioned earlier, a key distinction between a plan and a strategy is that a plan never names the real problem or challenge. A strategy, on the other hand, calls out the challenge or obstacle, and that helps you to judge if the strategy will get you past that obstacle.

  3. Mistaking “goals” for strategy. Another very common pattern I see in strategy documents is what looks like a target or goal. For example: “Grow revenue 25%”. Setting a number is good, but that alone doesn’t tell anyone how to hit it.

  4. Bad strategic objectives. The most common pattern I see is a long laundry list of twelve priorities, or objectives that are so vague that nobody can actually act on them. Your objective list needs to be short, crisp, and actionable.

👉🏻 A quick self-check: open your current team plan and highlight every sentence that’s a goal, a target, or a buzzword. After doing that, what’s left? For most documents I’ve seen, not much is left after that.

Which signs did you spot most in your strategy documents? Let me know in the comments.

Leave a comment


The Three Elements of the Kernel

Let me walk through each element using one example.

Consider this: Daniel is a Sr. Engineering Manager at a large software company, and runs a 25-person platform team. He puts together a first draft plan for the coming year, with this statement:

Improve developer experience, reduce incidents by 50%, migrate to the new CI system, and launch an internal developer portal.

Those are four goals, but there’s no plan or strategy.

1. Diagnosis: what’s really going on?

Similar to how a doctor tries to diagnose the root cause when you visit them with a symptom, the goal of diagnosis is to name the critical challenge.

In other words, diagnosis tries to take a messy situation, and simplify it down to the part that matters most.

In Daniel’s example, “We’re too slow” would be a weak diagnosis as it just repeats the symptom.

When Daniel asked the ‘why’, and dug in, he found that his senior engineers were spending about a third of their week answering escalations from product teams because the platform tools were hard to use without help.

That led him to identify something that he could act on.

2. Guiding Policy: what’s our overall approach?

The guiding policy is the “big-picture approach” to tackling the challenge you identified in the diagnosis.

This isn’t a long list of steps that you need to execute. Rather, it’s a set of guardrails, which provide a direction to move towards. And just as importantly, it calls out which options are now off the table.

Based on the diagnosis, here’s what Daniel set as the guiding policy: Make product teams self-sufficient before we build anything new.

Notice that it calls out what the team will not do. They will not work on the developer portal, or build new services. Instead, they will put their energies into ensuring that the product teams are able to self-serve without needing help from the team.

3. Coherent Actions: what will we actually do?

Coherent actions are the specific steps to carry out the guiding policy that was identified earlier.

I think the key word is coherent. The actions, or steps, should support each other rather than pulling in different directions.

Here’s what Daniel identified as his team’s coherent actions:

  • Freeze new feature work for one quarter.

  • Use the last six months of support tickets to find and fix the top five self-serve gaps.

  • Rotate one engineer each week as a “support shield” so the rest of the team can focus.

  • Track escalations per week as the main health check.

As you can tell, each action reinforces and complements the other. Freezing new feature work creates time for the fixes to the self-serve gaps. The fixes reduce escalations, and the support shield protects the team from other distractions.

Why the order matters

Most plans I’ve seen skip straight to actions. Actions generally feel like progress, so that’s the natural instinct for most managers.

But as you can probably tell from Daniel’s example, the order of the elements in the kernel matters.

If Daniel hadn’t run the diagnosis, he wouldn’t have been able to set the right guardrails as part of the guiding policy. And without those guardrails, every action would have looked equally good, and would have taken his team nowhere.


Test Your Understanding

Can you tell a diagnosis from a goal? Or a guiding policy from a slogan? It’s harder than it sounds. This short quiz gives you real planning statements and asks you to sort them.

Take the quiz now →


Practice this Framework

Just like you build your physical muscles in the gym, you build your leadership muscle by practice.

🎯 Practice a drill

Got five minutes? Drills are short, focused reps. Start a drill in Kyoshi to practice Rumelt’s Kernel approach and how it applies in a realistic situation.

Practice a drill now →


Part 2: Applying Rumelt’s Kernel

Practice makes you better, but you only really grow when you use a framework on your own problems.

Your situation has its own people, its own history, and, frankly, its own politics.

So here are two ways in which you can actually apply this framework in your own leadership role today.

This post is for paid subscribers

Already a paid subscriber? Sign in
© 2026 The Good Boss · Privacy ∙ Terms ∙ Collection notice
Start your SubstackGet the app
Substack is the home for writing, podcasting, and media founders.