Unblocking Squad A from Squad B means replacing unwritten assumptions with an explicit, checkable rule attached to the work — not more status meetings or a bigger tracker. Good dependency management spells out what "ready" and "done" mean at the handoff and enforces it, so a squad can't quietly build on work that was never finished.

Quick Answer: Stop documenting rules nobody checks at the point of work. Convert each recurring cross-squad dependency into an explicit Definition of Ready or Definition of Done item, then attach it to the ticket or spec as a binary gate, so a story can't advance until the rule is actually met.

Why the Same Squad Blocks You, Sprint After Sprint

The same cross-squad dependency keeps recurring because the rule it broke was never written down anywhere both teams could see — it lived in one person's memory, one Slack thread, or a retro action item that quietly expired. Naming the pattern precisely is the first step toward fixing it structurally instead of re-apologizing for it next sprint.

Picture a Search squad shipping a new filter feature that depends on a field in the product catalog index owned by a Catalog Platform squad. Search assumed the field would exist by sprint start, "because that's usually how it works." Catalog Platform assumed nobody needed it yet, because no one had formally asked. Neither team was wrong about their own process — they were relying on two different unwritten versions of the same rule.

A few signs a blocker is systemic rather than accidental:

  • The same two squads show up in the retro's "what blocked us" section more than once a quarter
  • The explanation is always some version of "we assumed you'd flag it" or "we didn't know that was needed yet"
  • The fix each time is an apology and a promise to communicate better, not a change to how either team actually works

Left alone, this pattern does more damage than the missed sprint itself. Search starts padding estimates to buffer for Catalog Platform's unpredictability, Catalog Platform starts feeling ambushed by requests it never agreed to, and both start routing around each other instead of through each other. The blocker becomes a relationship problem wearing a scheduling problem's clothes.

Mapping a quarter's worth of blockers against a customer journey view often shows they cluster around one or two handoff points — the same stage, the same pair of squads — rather than spreading evenly across the product. That clustering is the tell that your squad dependencies have a missing rule behind them, not a string of bad luck.

Why Better Communication and a Bigger Tracker Won't Fix This

Standard advice — hold a sync, write a RACI chart, keep a shared dependency spreadsheet — fails because none of it is checked at the moment work actually happens. A wiki page describing what "ready" means doesn't stop an engineer from picking up a story that isn't ready; only something inside their actual workflow does.

Documentation and meetings share the same structural weakness: they inform people, but they don't gate anything.

  • A RACI chart tells you who's accountable in theory — it doesn't stop a ticket from moving to "In Progress" before the thing it's accountable for has happened
  • A status meeting only reaches the people in the room, for the length of that meeting — by the next morning, everyone who wasn't there has to remember it correctly secondhand

PMI's Pulse of the Profession research has, across multiple years, found unclear or ineffective communication among the most commonly cited reasons projects miss their goals — not lack of effort, not lack of tooling, but a gap between what one group assumed was understood and what actually was. Cross-team coordination fails the same way at a smaller, more frequent scale: two squads each confident they know the rule, each working from a slightly different copy of it.

None of this makes meetings worthless — a sync is often exactly where a rule first gets discovered. The mistake is treating the meeting as the fix, instead of as the moment that produces the fix.

More documentation doesn't close that gap, because the problem was never information scarcity — both teams could usually have found the rule if they'd gone looking. This is part of why product management that operates beyond the standard Scrum ceremony list matters here: a ceremony creates space to state a rule out loud, but stating it once isn't the same as enforcing it every sprint.

A rule nobody checks isn't a rule. It's a suggestion with a paper trail.

Make the Rule Explicit, Then Make It Checkable

The fix isn't more documentation — it's converting an implicit norm into an explicit rule, then attaching that rule to a gate the work literally cannot pass without satisfying. Definition of Ready and Definition of Done are agile's native vocabulary for this. Most teams write them once, early on, and never enforce them again.

Systems theorist Donella Meadows, in her widely cited essay on leverage points for intervening in a system, ranked changing a system's rules well above tweaking its numbers or parameters — a new rule reshapes what's even possible to do inside the system, where a bigger tracker just records the same behavior in more detail. A dependency spreadsheet is a parameter change. A gate that blocks the ticket is a rule change. That's the entire difference in leverage.

Teams default to the spreadsheet anyway, because a new rule feels like it needs organizational authority a PM doesn't have, while a tracker only needs a spreadsheet. That's a real constraint, not a mistake.

Most cross-squad rules don't need executive sign-off. They need one sentence and a place to enforce it.

It's usually the size of the rule that gets overestimated, not the need for one.

It helps to think of any cross-squad rule as sitting at one of three maturity levels — most organizations have far more rules stuck in the middle than they realize.

Maturity levelWhat it looks like in practiceHow it fails
Implicit (tribal)"Everyone knows Catalog has to approve new index fields" — lives in one person's memoryNew hires and other squads violate it before they ever hear about it
DocumentedA wiki page, Definition of Ready doc, or onboarding deck states the ruleNobody consults it mid-sprint; it quietly goes stale after the next reorg
Checkable (gated)The rule is a required field, checkbox, or automated check on the actual ticket or specWork physically cannot advance until the condition is met — no one has to remember to enforce it

Most organizations already have plenty of rules sitting in the second row. The missing move is almost always the jump from the second row to the third, not the first.

Surgeon and writer Atul Gawande made a version of the same argument for an entirely different domain in The Checklist Manifesto. The surgeons already knew every individual step — a checklist's power came from making each one a required, checkable gate instead of an assumed one.

A widely cited 2009 study in the New England Journal of Medicine, built around the WHO Surgical Safety Checklist, tracked what changed once eight hospitals made the checklist mandatory:

  • Major surgical complications fell by roughly a third
  • Deaths fell by nearly half

Nothing about the surgeons' skill changed between the "before" and "after." What changed was whether a known step could be silently skipped.

The Scrum Guide, authored by Ken Schwaber and Jeff Sutherland, already gives agile teams a home for this: Definition of Done is meant to be a shared, explicit checklist the whole team holds work against, not a personal standard each engineer applies inconsistently. Where teams go wrong isn't inventing a Definition of Done — it's leaving it as a paragraph in a team charter nobody re-opens once the sprint starts.

Jez Humble and Dave Farley, in Continuous Delivery, push this further for release readiness: encode the rule as an automated gate in the pipeline, not a manual sign-off someone has to remember to perform. The same logic works one layer up, before code is even written — a cross-squad dependency can be gated at the spec or ticket level the same way a release is gated in CI.

From Wiki Page to Working Gate

Turning an implicit rule into a checkable one is a small, specific edit, not a new program: name the rule in one sentence, decide which artifact it should live on, and make satisfying it a precondition rather than a courtesy.

Implicit rule (unwritten, assumed)Explicit checkable gate
"Catalog approves new index fields before another squad builds against them"Story can't move to Ready for Dev until an approved field-request ticket is linked
"Design should be final before engineering estimates the work"Definition of Ready requires a design link tagged "dev ready" plus one named reviewer's sign-off
"Security will flag it if there's a problem"The pull-request template requires a completed security checklist before merge is enabled
"QA will catch anything we missed"Definition of Done requires attached test evidence before a ticket can close

None of these four rewrites invented a new process. Each one just moved an existing sentence from someone's head, or a wiki page, onto the object the team can't avoid looking at.

Each rewrite also answers a question the implicit version never could: what happens if the condition isn't met? With the tribal version, the answer was "someone gets annoyed later." With the gated version, the answer is "the ticket doesn't move" — which is a much shorter path to actually fixing it.

Five Moves to Turn Implicit Norms Into Checkable Gates

Fixing this doesn't require a new framework — it requires deliberately converting the specific rules that keep breaking, starting with whichever one has already cost you a sprint at least twice. These five moves are ordered the way most teams can actually execute them, cheapest first.

  1. Mine your last five blockers for the unwritten rule that broke. Pull recent retro notes or postmortems and write the causing assumption as one plain sentence — "Catalog assumes no one needs a field until it's formally requested." Not every miss deserves a permanent gate: running the dependency through a Jobs to Be Done lens on why the requesting squad needed it at all separates a structural rule worth encoding from a one-off scoping mistake. If the same pair of squads shows up three times, write the gate; if it's a one-time fluke, a Slack message closes it out just fine.
  2. Attach the rule to the artifact, not a policy doc. A gate that lives in the ticket template, the Definition of Ready checklist, or the spec itself gets seen at the moment it matters — including the moment sprint planning turns backlog intentions into a real commitment, the last natural checkpoint before an unmet dependency becomes the sprint's problem. A gate that lives only on a wiki page gets seen during onboarding and never again.
  3. Make pass or fail binary, never a judgment call. "Roughly ready" isn't checkable; a linked approval, a completed field, or a passing check is. This is exactly the discipline meaningful backlog grooming is supposed to enforce — a story shouldn't leave grooming with an open dependency disguised as a minor detail.
  4. Give exactly one person the authority to fail the gate. A gate anyone can wave through under deadline pressure isn't a gate, and without a named owner a blocked story tends to get reprioritized around instead of resolved. Deciding whether that person is the PM, the PO, or a tech lead is a live version of the tension covered in how the PM role actually plays out versus the Scrum textbook — pick whoever is genuinely close enough to the work to make the call, not whoever holds the title.
  5. Review the gates themselves on a cadence, and prune the ones that calcified. Scaled frameworks like SAFe build this in deliberately: PI Planning exists specifically to surface cross-team dependencies on a recurring cadence, in a room, before they become mid-sprint surprises. Borrow the cadence without adopting the whole framework — a quarterly pass that retires any gate no longer preventing real misses keeps the system from calcifying into the bureaucracy it replaced. A team that needs a legend to remember what all its gates check has already overcorrected.

Where Prodinja Fits: Turning the Rule Into a Gate the Spec Enforces

A gate only works if it's genuinely impossible to skip, not just discouraged — which is as much a tooling problem as a process one. That's the specific gap Prodinja's Spec Studio, part of an AI PM copilot currently shipping as an interactive prototype, is built to close.

Spec Studio treats a product spec as a living PRD — PR-style diffs, a structured hand-off — instead of a static document. Its readiness gates let a PM encode a Definition of Ready or Definition of Done straight into the spec, so a story can't move forward to the next stage until the gate actually passes, not just until someone remembers to check it.

It's the same wiki-page-to-working-gate shift covered above, built into the artifact the team is already working from instead of bolted on as a separate policy.

Key Takeaways

  • Recurring cross-squad blockers are a missing-rule problem, not a communication problem — the same two squads colliding repeatedly means an assumption was never made explicit, not that anyone tried less hard.
  • Documentation and checkable gates are not the same thing — a wiki page informs; a gate attached to the actual ticket or spec physically prevents work from advancing until the condition is met.
  • Rules outrank parameters as a leverage point — a new gate changes what's possible inside the system, while a bigger tracker just records the same behavior in more detail.
  • Definition of Ready and Definition of Done are agile's built-in home for this fix — most teams already have them and simply stopped enforcing them after the first sprint.
  • Every gate needs exactly one person with the authority to fail it — a rule anyone can wave through under deadline pressure isn't functioning as a rule.
  • Not every dependency deserves a permanent gate — reserve the friction for rules that have already caused a repeat miss, and prune gates that stop earning their keep.
  • Review gates on a cadence, the way scaled frameworks like SAFe review dependencies at PI Planning — an unreviewed gate calcifies into the same bureaucracy it was built to replace.

Frequently Asked Questions

What is cross-squad dependency management?

Cross-squad dependency management is the practice of identifying where one team's work relies on another team's output and making that reliance explicit enough to plan around, instead of discovering it mid-sprint. Done well, it turns an unwritten assumption about what another squad will deliver, and by when, into a rule both teams can actually check.

How do you stop a dependency from becoming a recurring blocker?

Write down the specific assumption that broke last time, then attach it as a checkable condition — a required field, a linked approval, an automated check — to the artifact both teams actually work from. A dependency stops recurring once satisfying the rule is a precondition for moving forward, not a courtesy someone can skip under deadline pressure.

What's the difference between a definition of ready and a definition of done?

A Definition of Ready gates work entering a sprint or a squad's queue — the input conditions that must be true before a story is pulled in. A Definition of Done gates work leaving it — the output conditions required before it counts as complete. Cross-squad dependencies usually need both, since one team's Definition of Done is often another team's Definition of Ready. Confusing the two is a common reason a story looks "ready" to the team handing it off and "not remotely done" to the team receiving it.

Who should own a cross-squad dependency — the PM or the Scrum Master?

Whoever has both the authority to fail the gate and enough proximity to know when it's genuinely satisfied — which varies by organization more than by title. A PM often owns the outcome the dependency threatens; a Scrum Master or tech lead may sit closer to the daily handoff. The important part is naming one person, not defaulting to whichever role sounds most responsible.

How many gates is too many for one team to manage?

There's no fixed number, but if engineers start treating gates as friction to route around rather than a real check, there are probably too many — or too many checking things that rarely go wrong. A useful test is provenance: every gate should trace back to a real blocker it prevented at least once, or it's a candidate for pruning. Teams that spend real effort removing dependencies, not just working around them, tend to need noticeably fewer gates in the first place.