This document discusses strategies for scaling software development teams while minimizing technical debt. It advocates separating teams into roles including developers, team leaders, and engineering managers. Team leaders are responsible for driving cadence and morale, ensuring deadlines are met, and mentoring developers. Engineering managers focus on skills development and removing barriers. Regular, predictable delivery of features through steady cadence is emphasized over long release cycles to reduce technical debt. Separating concerns like architecture from UI helps determine appropriate processes along the agile-waterfall spectrum.

1. Scaling is about Un-Scaling
Technical Debt

2. Jeff Szczepanski
Chief Operating Officer
talljeff@stackoverflow.com

3. Suffering from Technical Debt?
• Regular Schedule Slips?
• [Frequent] Need to Refactor things?
• Irregular and Inconsistent Output of New Features?
• Adding New Developers Doesn’t Speed Things Up?
• Buggy Code and Frequent Regressions?
• Ongoing Performance or Stability Problems?
• Slow Turnarounds of Bug Fixes?
• Bug Fixes for Your Bug Fixes?

4. Suffering from Technical Debt?
What do you do?

5. REWRITE!

6. Wait, REWRITE?

7. V1.0 V2.0 V3.0
Another Kind of Technical Debt
How Much Code Are You Tossing?
How Much Tossing was Really Unavoidable?

9. Definition of Technical Debt
Misalignment of what is easy to do with your
code base and data structures vs. what you need
them to do for your Product(s) to be [more]
successful in the Marketplace

10. Time
Features &
Functionality
The Hot Coals of Growth

11. Evolving Bar Of Quality
80/20 Rule
90/10 Rule
95/05 Rule
99/01 Rule

12. Customer Compelled vs. Market
Focused
The Debt Comes Not Just From Being Customer
Compelled in Feature Definition, but it Comes
from Being Customer Compelled in How Your
System is Designed.

13. How Do We Ensure This?
Time
Features & Whole
Product Quality
…in the eyes
of your
customers

14. Key to Scaling Your Business
>>> Bringing your Customers and Their
Data Along With You on Your Road Map

15. Holy Wars
ie: Let’s Talk About Software Process

16. Agile Good
Everyone Agrees, Right?
Waterfall Bad

17. Good Properties of Agile
• Admits that Requirements Evolve
• Encourages Regular Releases
– Which allows Validation of progress more often
• Sprints are Excellent for Driving Cadence
• Closes the Loop Relative to Quality
– Quality in all forms

18. Pitfalls of Agile
• Scheduling Beyond a Few Sprints Seems Rare
• Implicitly Encourages Feature Centric Thinking
– At the Expense of Good System Design
• Incremental Nature encourages Short Cuts
– Lighter Specs, Lighter Documentation, etc.
->> Why plan or document things in too much detail
when it’s just going to change anyway.

19. Good Properties of Waterfall
• Formal Specifications Rule
• Emphasizes Detailed Planning
• System Design is specifically a thing
• Highly Efficient, if Requirements are Solid

20. Pitfalls of Waterfall
• Requirements are Never Perfect
• Encourages Long Serial Release Cycles
– Spec Everything, then Design Everything, then
Build Everything, then Test Everything
• Problems Discovered Late
• Cost of Errors High

21. Observation
• Pitfalls of Agile are pretty much
the Strengths of Waterfall
• Strengths of Agile are pretty
much the Pitfalls of Waterfall

22. The Agile - Waterfall Continuum™
Agile Waterfall

23. Key Variables to Consider
• Length of Release Cycles
• Clarity/Confidence of Customer Requirements
• Depth of System Complexity
• How Catastrophic Are Defects?
• Size of Software Team/Customer Base

24. Agile
Waterfall
• Requirements Discovery/Validation
• Incremental Feature Delivery
• Simple Systems close to UI
• The progression of “dot” releases
• Architecture Phases
• Development of Core Services
• Complex Modules far from UI
• The Things that Deliver on Your
Differentiation and Positioning

25. Visualizing This
…and Getting a Little More Practical

26. Crazy/Hot Matrix

28. The Joel Test
• Do you use source control?
• Can you make a build in one step?
• Do you make daily builds?
• Do you have a bug database?
• Do you fix bugs before writing new code?
• Do you have an up-to-date schedule?
• Do you have a spec?
• Do programmers have quiet working conditions?
• Do you use the best tools money can buy?
• Do you have testers?
• Do new candidates write code during their interview?
• Do you do hallway usability testing?

29. Additions for Teams At Scale
• Do you Document Your Services & Major
Modules?
– Concise Description of Role & Scope
– The Full API and all the Interface Data Types
– Key Design Assumptions & Dependencies
– Single Person on the Team that Owns each

30. Additions for Teams At Scale
• Do you Document all Your Data?
– Text for Role of every Table
– Text on Purpose and Invariants for
Every Column
– Owner that reviews every field
addition/deletion

31. Additions for Teams At Scale
• Do you Enforce a Coding
Standard?
• Do you do Code Reviews?

32. Additions for Teams At Scale
• Do You Track Bugs Back to Their Source?
– Closes the Loop on Quality
– Looking for brittle modules
– Looking for programmers in need of mentoring

33. Additions for Teams At Scale
• Do you Define Deadlines and Hit Them?
– Ie: Can you Make Predictable Schedules?

34. Scheduling Skeptic?
Why spend time making a schedule we’ll just
end up missing….we’ll put that time into the
building functionality.

35. Schedule Skeptic?
Why bother digging that foundation, you’re just
increasing the height of the building we need to
build.

36. Why Schedules are Important
• Sales, Marketing, Support & Customers all
care when things will ship
• Good Roadmap Decisions Depend on Valid
Cost/Benefit Tradeoffs

37. Why Schedules Are Important
How else do you deterministically evaluate the
performance of your developers or your
development team?

38. Why Schedules Are Important
Predictability is a Symptom of High Quality
Software Development

39. Key Point
Having Reliable Software Schedules
is crucial to efficient scaling and
continuous output.
ie: Good Schedules is Good Business

40. More On Schedule & Cadence
• Schedule Slips are a Learning Opportunity
– Estimation is a Specific Skill, so Develop It In
People
• It’s Better to Do Structured Slips than
Cramming
• Each Team Should Have an Anchor and a
Rover

41. Pulling It Together
Team Organization

42. Lots of Skills at Play Here
• Discovering, Developing and Finalizing Requirements
• System Architecture, Design and Code Construction
• Quality Control including effective testing and
validation
• Task Estimation and Project Management
• Deployment and Ongoing Maintenance
• Team Morale and the Things that Drive Cadence

43. Important Observations
• Understand Performance != Results
• Bunches of Separable Skills to Develop
• Desire Steady Cadence & Continuous Output
• Must pay attention to Motivation and Morale
• Seek to Empower and Enable, not Manage

44. Three Key Roles
• Developers: As team members
• Team Leaders: As Player & Coaches
• Engineering Managers: Skills Development

45. Team Leader
• Walking Personification of Your Ideal Developer
• Natural Leaders that enjoy Mentoring
• Drives Cadence and Morale of the Team
– Usually the Scrum Master for the Team
• Responsible for Team meeting its Deadlines
• In Charge of Quality of what the Team is Building
• Player and a Coach -> Still Codes on the Team
• Eyes and Ears for Engineering Management
– Spot treatments not skills development

46. Engineering Manager
• Primary Responsibility is Skills Development
• Line Manager of all the Developers
• Removes Operational Barriers
– Helps define and deploy common tools & infrastructure
• Works with a Longer Term Horizon
– More Month to Month than Day to Day
• Role Specializes as Organization Grows
– Splits into Operational Aspects and Skills Development Aspects

47. Role Separation
Team Leaders => Track Racing Pit Crew
Engineering Management => Garage Mechanics

48. On Team Morale and Cadence
• Bottom Up Estimates Only
• Strive for Continuous and Steady Output
– Expect Ownership of Goals but No Death Marches
• Use Peer and Social Pressure vs. Edicts
– Setting Cultural Norms and Expectations
• Merit not tenure based Advancement

49. In Summary
• Minimizing Technical Debt is About Matching
Your Code Base and Data to your Market
• Predictability Highly Correlates to Quality
• Understand Performance != Results
• Ultimate Goal is Developing a Suite of Strong
Skills in Each Developer

50. Questions?
Thank You!
talljeff@stackoverflow.com
@inscitekjeff