Vision, strategy, tactics, and execution: the four layers

Description

Up to this point you've used two words with precision: tactics (how you climb the wall) and strategy (which mountain you choose). But in any real product conversation you're going to hear, mixed together carelessly, two other words that aren't synonyms for either of the previous ones: vision and execution. A VP of Product says "our vision is X" in the same sentence where someone else says "our strategy is Y," and a new engineer in the room reasonably wonders if they're the same thing said twice. They're not. This lesson organizes the four words into a four-layer hierarchy, each one answering a different question, so you never have to guess again which layer a sentence you just heard is standing on.

Connection to the module. This lesson doesn't add any new executed model — it's, on purpose, a map-and-vocabulary lesson, so you can precisely place, for the rest of this guide and the rest of the ecosystem, which layer each question lives in. Lessons 2, 3, and 4 gave you the central pair (tactics/strategy) in depth; this lesson completes the picture with vision and execution, and draws the exact boundary with modules 2 and 7 of this same guide, and with product-thinking-for-engineers-guide.

An analogy: the control tower, the pilot, the co-pilot, and the wheels

Think of an entire airline as a system of four distinct roles, each looking at the flight from a different level of abstraction. The airline's control tower (not a flight's, the whole company's) decides, years out, why the airline exists and what kind of future it's aiming at — being the airline that connects mid-size cities nobody else serves, for example. That's vision: the distant horizon, the "why" and the "toward where," which almost never changes from one quarter to the next.

The pilot of a specific route decides, for that route, which airports to serve and with what type of aircraft — maybe deciding to focus on short routes with small planes instead of competing for the transatlantic routes where the big airlines already dominate. That's strategy: a concrete choice, with something given up (the transatlantic routes), made to serve the control tower's vision.

The co-pilot decides, flight by flight, in what order to load fuel, when to start the descent, how to adjust the route if there's a headwind — tactical decisions within the flight plan the pilot already chose. That's tactics: executing well, with judgment, within an already-decided game.

And the wheels touching the runway on today's landing, at 2:32 p.m., at gate 12 — that's execution: the present moment, concrete, verifiable, where everything above either really happened or didn't.

The four layers exist at the same time, in the same airline, and none replaces the other: a vision without a strategy is a dream with no flight plan; a strategy without tactics is a flight plan nobody knows how to execute; and all the control towers in the world don't land today's plane if nobody touches the controls at 2:32 p.m.

The four layers, applied to Mercado

┌─────────────────────────────────────────────────────────────────┐
│  VISION       "The marketplace where you discover what you      │
│               didn't know you wanted."                           │
│               Horizon: years. Changes almost never.              │
│               → Built in module 2 of this guide.                 │
├─────────────────────────────────────────────────────────────────┤
│  STRATEGY     "We focus on buyers who browse, sacrificing        │
│               exact-SKU search traffic."                         │
│               Horizon: quarters to years. Changes rarely.        │
│               → Built in modules 3 through 6 of this guide.      │
├─────────────────────────────────────────────────────────────────┤
│  TACTICS      "We prioritize 'saved payment methods' over        │
│               'dark mode' this quarter (RICE)."                  │
│               Horizon: sprints to quarters. Changes often.       │
│               → Is product-thinking-for-engineers-guide.         │
├─────────────────────────────────────────────────────────────────┤
│  EXECUTION    "Today: close PR #482 for the save-card button."   │
│               Horizon: today. Changes every day.                 │
│               → Is the daily work of building (Fullstack).       │
└─────────────────────────────────────────────────────────────────┘

Notice the relationship between layers: each one constrains the one below it, without dictating every detail. Vision doesn't tell strategy exactly which segment to choose — but it does rule out any strategy that contradicts it (a vision of "curated discovery" rules out, from the start, a strategy of "compete on the lowest possible price regardless of catalog quality"). Strategy doesn't tell tactics in what order to prioritize each backlog feature — but it does rule out, from the start, any bet that doesn't serve the chosen segment (this is, exactly, what module 7 is going to formalize as strategicFilter: a step before RICE gets a say). And tactics doesn't tell today's execution every line of code — but it does decide what gets built first.

Worked example: the four layers, printed in order

Let's look at the full map, with a real example of each layer for Mercado, printed in the order they actually constrain one another — top to bottom.

// Mercado's 4 layers, from the highest (why it exists) to the lowest (what gets
// executed today). It's not a model that decides -- it's the map you'll use for
// the rest of the guide to place any sentence you hear in a meeting.
const mercadoLayers = [
  { layer: 'vision', example: 'The marketplace where you discover what you didn\'t know you wanted.' },
  { layer: 'strategy', example: 'We focus on buyers who browse, sacrificing exact-SKU search traffic.' },
  { layer: 'tactics', example: 'We prioritize "saved payment methods" over "dark mode" this quarter (RICE).' },
  { layer: 'execution', example: 'Today: close PR #482 for the save-card button.' },
];

console.log('=== Mercado\'s 4 layers, top to bottom ===\n');
mercadoLayers.forEach((l, i) => {
  console.log((i + 1) + '. [' + l.layer.toUpperCase() + '] ' + l.example);
});

What to expect. Running the file with Node, the output is exactly this:

=== Mercado's 4 layers, top to bottom ===

1. [VISION] The marketplace where you discover what you didn't know you wanted.
2. [STRATEGY] We focus on buyers who browse, sacrificing exact-SKU search traffic.
3. [TACTICS] We prioritize "saved payment methods" over "dark mode" this quarter (RICE).
4. [EXECUTION] Today: close PR #482 for the save-card button.

Notice how each sentence, read in isolation, has a different timescale implicit in its own language: the vision one mentions no deadline, the strategy one says "we focus" (a sustained stance), the tactics one says "this quarter" (a bounded window), and the execution one says "today" (the exact present). That progression of timeframes — from "always" to "today" — is a good quick heuristic for placing any sentence you hear: if someone says "today we're going to...," you're almost certainly in execution or tactics; if they say "we will never compete on...," you're almost certainly in strategy or vision.

Where each layer lives in the Product Engineering ecosystem

This lesson is also the module's most complete boundary map, and it's worth making it explicit before moving on:

• Vision — built in module 2 of this same guide (module-02-vision-and-mission). There you'll define Mercado's complete vision, and how a clear vision restricts as much as it enables: it says both NO and YES.
• Strategy — built in modules 3 through 6 of this guide: segment and positioning, differentiation, competition, moats. This module 1 doesn't build any piece yet; it gave you the criterion to recognize them when they arrive.
• Tactics — is, in its entirety, the territory of product-thinking-for-engineers-guide: RICE, opportunity sizing, MVP, bets, and risky assumptions. Module 7 of this guide (module-07-strategy-to-roadmap) is the exact hinge between the two: it takes the full strategy (modules 2 through 6) and turns it into a filter applied before product-thinking's tactics prioritize with RICE.
• Execution — is the daily work of building: code, architecture, deployment. It lives in the Fullstack and Architecture ecosystems, and this guide never enters there — it only informs, in lesson 6, some technical execution decisions like build-vs-buy.

A short way to remember it: if the question starts with "why do we exist, where are we headed?", it's vision. If it starts with "where do we play and how do we win, what do we give up?", it's strategy. If it starts with "what do we build first, how big?", it's tactics. If it starts with "what do I do right now?", it's execution.

Common mistakes

Using "vision" and "strategy" as interchangeable synonyms. What happens: in the same meeting, someone says "our vision is to dominate the market" and ten minutes later "our strategy is to dominate the market" — the same sentence, two different labels, without anyone noticing the inconsistency. Why it happens: the two words sound equally "big" and "important" in everyday business language, and rarely does anyone demand the precise distinction. How to spot it: if you can swap "vision" for "strategy" anywhere in the planning document without anything changing in meaning, neither word is being used precisely. How to fix it: apply the timeframe-and-choice test — a vision has no defined deadline and names no concrete trade-off ("the marketplace where you discover what you didn't know you wanted" never expires). A strategy does name a choice with a trade-off, and usually gets revisited every year or two. If the sentence names no trade-off, it's probably a vision (or, worse, a bad strategy in disguise — lesson 3 already gave you the criterion for that alarm).

Treating tactics as if it could compensate for a missing strategy. What happens: a team, with no explicit strategy defined (nobody completed modules 2 through 6, in this guide's vocabulary), jumps straight into prioritizing the backlog with RICE, assuming "prioritizing well" is already enough guidance. Why it happens: RICE gives a sense of rigor and objectivity — there are numbers, there's a formula — that feels like it replaces the strategic question that was never asked. How to spot it: the prioritized backlog has high-RICE items that, if you ask "which segment does this serve, and why does it fit our choice of where to play?", nobody has a clear answer. How to fix it: remember the relationship between layers — strategy constrains which bets even compete for priority; RICE decides the order within those already-filtered bets. Without that prior filter, a high RICE score can be prioritizing, with complete mathematical rigor, something that shouldn't be on the list at all.

Asking vision to answer tactics-level questions. What happens: in the middle of a discussion about what to build this week, someone invokes the vision ("our vision is X, so we should build Y") as if the vision, by itself, answered this week's decisions. Why it happens: the vision is the organization's most memorable, most repeated sentence, and it feels natural to invoke it for any decision. How to spot it: Mercado's vision ("the marketplace where you discover what you didn't know you wanted") is compatible with dozens of different features — it doesn't choose between them, because that isn't its job. How to fix it: vision filters at the strategy level (does this general direction fit where we're headed?), not at the tactics level (this specific feature, this week?). For that second question you need to drop two layers, down to the already-defined strategy and product-thinking's prioritization criteria — invoking vision there is like asking the control tower to decide in what order the co-pilot loads fuel.

Exercises

Exercise 1 — Place the layer. For each sentence, say which layer it lives in: vision, strategy, tactics, or execution.

• (a) "In five years, any small seller in the region is going to think of Mercado before any other platform."
• (b) "We're going to build the seller reputation system before the checkout visual redesign, because it has higher RICE."
• (c) "We serve buyers who browse, not those searching for an exact SKU — and we give up competing head-on in search precision."
• (d) "In today's standup: finish the reviews table migration."

Exercise 2 — Find the missing layer. A team has a clear vision ("be the neighborhood's discovery place") and a RICE-prioritized backlog, but jumps straight from one to the other, with no explicit strategy in between. What concrete problem can show up, and why is the strategy layer the one that prevents it?

Exercise 3 — Rewrite the sentence at the right layer. The sentence "we're going to be the best in user experience" shows up, without anyone noticing, mixed indiscriminately as vision, as strategy, and as tactical prioritization criteria in different meetings of a fictional team. Write a version of that idea for each of the three layers (vision, strategy, tactics), so each version has the correct shape for its layer.

Vision (no trade-off, long horizon):
"The place where shopping feels simple and trustworthy, not a chore."

Strategy (with an explicit trade-off):
"We prioritize flow simplicity over on-screen option variety,
even if that means showing fewer products per search than competitors."

Tactics (an ordering decision, with an explicit criterion, this season):
"We prioritize 'simplified 3-step checkout' over 'wishlist and favorites'
this quarter, because its RICE is higher."

Summary and next step

In this lesson you organized the module's full vocabulary into four layers — vision, strategy, tactics, execution — each with its own time horizon and its own question. With Mercado's four-layer map, you saw how each one constrains the one below it without dictating every detail, and you traced the complete boundary map: vision and strategy are this guide (modules 2 through 6), tactics is product-thinking, execution is Fullstack, and module 7 of this guide is the exact hinge between strategy and tactics.

Before moving on you should be able to: name the four layers in order, from highest to lowest; place any new sentence you hear in the right layer using the timeframe-and-trade-off test; and explain why tactics can't compensate for a missing strategy.

Lesson 6 answers the objection you probably already thought of on seeing that "strategy," on this map, lives far from "code": why is this your job, as an engineer, and not just the job of whoever holds the VP of Product or founder title? There you'll see, with a worked example on build-vs-buy decisions, why your technical judgment is, often, the only thing that can catch in time whether a technically attractive bet actually serves the strategy.

Resources

• Roger L. Martin, Playing to Win: How Strategy Really Works (with A.G. Lafley) — rogerlmartin.com/lets-read/playing-to-win. The framework of strategic decision layers, with the "where to play" and "how to win" questions at its center. In English.
• Marty Cagan (Silicon Valley Product Group), "Product Strategy" — svpg.com/product-strategy-overview. Cagan distinguishes, in the same spirit as this lesson, between objectives, roadmaps, and a real product strategy. In English.