This post is inspired by the problems encountered coaching a solution delivery stream where Conway’s law was in practice: there was a lack of alignment between product architecture, organisation structure, and development teams.
Many companies are slow because their teams constantly wait for each other. The solution isn’t working harder—it’s removing the need to coordinate in the first place.
The Core Problem
When teams depend on other teams to get work done, everything slows down. One team waits for another to finish their database changes. Another team waits for design approval. A third team waits for security reviews. These dependencies create bottlenecks that make simple changes take weeks instead of days.
The root cause is misalignment between three things:
• How your product is built (architecture)
• How your teams are organized (structure)
• How you deliver features (process)
When these three elements work together, teams become autonomous and fast. When they don’t, you get coordination chaos.
Three Principles for Speed
1. Give Teams Complete Ownership
Each team should own a complete slice of your product—from user interface to database. They shouldn’t need to ask other teams for permission or wait for other teams to make changes.
Instead of this:
• Frontend team builds user interfaces
• Backend team builds APIs
• Database team manages data
• Each feature requires all three teams to coordinate
Do this:
• Payments team owns everything related to billing
• Search team owns everything related to finding content
• Messaging team owns everything related to communication
• Each team can ship features independently
2. Match Your Architecture to Your Teams
Your technical architecture should mirror your team structure. If you want independent teams, you need independent systems.
Bad architecture:
• Shared database that all teams modify
• Monolithic codebase where changes affect everyone
• APIs that break when one team makes changes
Good architecture:
• Each team has their own database
• Services communicate through stable APIs
• Teams can deploy without affecting other teams
3. Eliminate Approval Chains
Teams should be able to ship features without waiting for approvals from other teams. This requires building quality controls into the process instead of adding them at the end.
Instead of waiting for:
• Security team approval before deploying
• Design team approval for UI changes
• Product team approval for feature decisions
Build in automatic checks:
• Automated security scanning during development
• Design systems that ensure consistency
• Clear success metrics that guide decisions
Getting Customer Feedback Fast
The fastest teams get customer feedback within hours, not weeks nor months. This requires changing how you collect and use customer input.
Traditional approach (slow):
• Quarterly customer surveys
• Long user research studies
• Annual customer advisory meetings
Fast feedback approach:
• In-app feedback buttons
• Weekly user interviews
• Direct customer access for all team members
• Real-time usage analytics
When engineers talk directly to customers and see usage data immediately, they make better decisions faster.
Making the Change
Start small and focus on one team at a time:
Week 1-2: Pick one team
• Choose a team that touches a clear customer experience
• Map out what they currently depend on other teams for
• Identify the biggest bottleneck
Week 3-4: Remove one dependency
• If they wait for database changes, give them database access
• If they wait for design approval, embed a designer
• If they wait for deployment, give them deploy access
Week 5-6: Add customer connection
• Set up direct customer feedback tools
• Have team members join customer calls
• Give them access to usage analytics
Repeat for other teams
What Success Looks Like
You’ll know this is working when:
• Teams ship features weekly instead of monthly
• Customer complaints decrease because teams catch issues faster
• New features get higher adoption because they solve real problems
• Teams are happier because they can see their impact
Common Mistakes
Mistake 1: Trying to change everything at once
Start with one team and one dependency. Build success before expanding.
Mistake 2: Focusing only on technology
Organizational changes are harder than technical changes. Invest in both.
Mistake 3: Removing coordination without adding feedback
Teams need direct customer input to make good decisions independently.
Mistake 4: Not measuring the change
Track deployment frequency and customer satisfaction to know if it’s working.
The Bottom Line
Fast companies aren’t fast because they work harder. They’re fast because they’ve eliminated the coordination that slows everyone else down.
When teams own complete customer experiences, have the technical tools to ship independently, and get direct customer feedback, they can respond to market changes in days instead of months. This speed becomes a competitive advantage that’s hard for slower organizations to match.
The investment required is significant, but so is the payoff. In markets where customer needs change rapidly, organizational speed isn’t just an advantage—it’s survival.
Agile Ways 