Alignment & Management

Alignment is an essential piece in the puzzle of an organization to be successful. There are vastly significant approaches of establishing alignment. Let us ponder two diametrically opposed philosophies of alignment. Rather than providing answers, I present you with two images and will ask some questions for your own reflection.

Scenario A

Managers create alignment by allocating assignments to teams

Let us ponder a few points:

• How likely will our Manager (M) get the Widget that is needed?
• How efficiently will the team (T) work on the Widget?
• How will S contribute to the organization – in the short term and long term?
• What is required to keep everyone aligned? Who needs to invest this effort?

Scenario B

Managers keep their hands off as long as the strategic direction is suitable

Let us ponder a few points:

• How likely will the Widget be exactly as needed?
• What happens to effectiveness when S joins?
• Which are the likely effects of having S join T? Consider side effects.
• What is required to keep everyone aligned? Who needs to invest this effort?

Comparison

Finally, let us compare the outcome of the two scenarios:

• Which approach will deliver the more valuable Widget?
• Which approach has lower total cost of ownership? Consider the costs of:
• Management
• Waste
• Delay
• Knowledge
• Recruiting
• Opportunity (for getting other things done)
• Which approach will result in a more stable company? Consider:
• Keeping alignment
• Profitability
• Risk of failure

Conclusion

Is active management intervention the best way to align an organization?
Draw your own conclusions.

Six simple ways to understand Scrum team maturity

When you're a Scrum Master, working an a new environment - with a new team, it's imperative to have a good understanding of the team's agile maturity. Why? Teams with low maturity need more  guidance - teams with high maturity need more opportunities to reflect. To not be the Elephant in the Glasshouse and spoil your relationship with the team early on, you need to understand how mature your team is before you act.

The Scrum Master's leadership style is based on the team's level of maturity

With this fairly self-explanatory model, here are a few pointers to help you determine how mature your new team is. Note that this is not a binary scale - it's more a gradient that can be anywhere and vary for different topics.

Problem solving

Mature teams have a working way of solving problems. Problems are not shoved under the rug, they are openly discussed and actively resolved. In all but the most special cases, the Scrum Master is not required as part of the solution.
Teams with a low level of maturity may choose to ignore known problems or require active intervention from the Scrum Master in the resolution process. In extreme cases, the Scrum Master needs to solve the problem for the team.

Collaboration

Mature teams are mostly focused on the shared team objectives. They arrange their activity and collaboration around delivering value to the customer. 

Immature teams tend to focus on the work of each team member. There are many handovers in the delivery process. People think in personal functions rather than business outcomes.

Getting things Done

Mature teams don't like to stack up undone work. They like to work on as few items as possible and get these done as fast as possible. They won't touch a new backlog item until their last one is Done.
Teams with a low level of maturity might shy back from "tough" work and put it on hold until more information becomes available or until the problem "disappears".

An easy assessment of the team's maturity is a quick glance at the Scrum board throughout the Sprint: Is WIP limited, how fast are items moving from "In Progress" to "Done"?

Process change

Mature teams constantly modify their ways of working. They continuously use controlled experiments to break their process in order to discover new, better ways of developing software. It's impossible to formally define their process, because by the time you'd jot it down, the documentation would be outdated.
Immature teams either meddle with their process without deeply understanding the impact of their action - or they are too scared to experiment without having formally approved the change in a Retrospective. They might even prefer a clearly defined process to follow and would rather master this process than make a disruptive change.

Ceremony behaviour

Mature teams run their own ceremonies and they get the necessary outcomes to continue working effectively. Immature teams need active facilitation and moderation - in some cases, even content guidance to reach the intended outcomes. Extremely immature teams will skip the meeting unless the Scrum Master actively invites them.

In general, ceremony conduction follows a bell curve: Learners spend less time, because they don't see the need, advanced practitioners invest a fair amount of time to maximize the effectiveness of the ceremony - while mature teams obtain the same outcome with significantly less effort, following the 10th Agile Principle of Simplicity.

Ceremony effort curve:

The Ceremony Effort curve needs to be clearly understood: For an outsider, there is little difference between a "Shu" learner and a "Ri" Grandmaster. Observing the team mechanics in detail and understanding the intended outcome very thoroughly is essential in determining whether you're encountering a mature team or not. Oftentimes, immature teams consider themselves mature.


Daily Scrum
Immature teams "report status" and "track progress". They are more focused on their portion than on the team objectives.
Mature teams use the Daily to sync each other and come up with the most sensible team plan for the next 24 hours.
Really mature teams don't need much of a Daily, because they are continuously planning and continuously syncing.

Refinement
Immature teams don't refine or delegate refinement responsible to the Product Owner: The Sprint Planning is often an unpleasant surprise for all those involved.
Mature teams refine in mutual interaction between stakeholders/customers, PO and team. They meet as often as necessary to guarantee enough "Ready" backlog for the next Sprint Planning.
Really mature teams don't need to refine, because they have mastered the art of delaying decision making to the latest possible moment. They are comfortable with lacking clarity until they actually start developing. The need to acquire information does not affect their development speed.

Planning

Immature teams are often befuddled at the intention of Planning. The typical beginner's planning looks like this: PO introduces Product Backlog items and asks "Do you have any questions?" (no). Then, the team decides what to work on, occasionally doing estimation and task breakdown. (Usually, the plan doesn't work out because significant items were missed.)

Mature teams use the Planning as an opportunity to explore intentions behind each item and come up with hard questions to challenge their own understanding of the request and how it should be implemented. They might argue over the solution, as there is not "one best way" to do things.

Really mature teams use the Planning ceremony to get a quick glance, as they are comfortable with delaying detailed decision making until they actually work on the item. They are clear on the intention and approach because of deep, shared understanding.

Review
Immature teams fail to hold Reviews or do so ineffectively. It's more of a Demo and approval session. In extreme cases, it becomes a blame session where stakeholders accuse developers of misunderstanding or developers accuse stakeholders of miscommunicating.
Mature teams use the Review as a tremendous mutual learning opportunity, gaining deeper insights into the customers' minds and enabling the Product Owner to add more value to the backlog.
Really mature teams don't invest much into the Review, because they continuously gather information about customer needs and satisfaction in real time.

Retrospective
Immature teams use the Retrospective as a small break from "real work". The outcome of a beginner's Retrospective is often an obvious change with marginal impact on the delivery capability. The question, "Why are we even doing this?" is quite common.
Mature teams dig deeply into their process to unearth hidden pitfalls and treasures. They take the chance to discover significant improvement potential in their ways of working.
Really mature teams use Retrospectives as a reflection space to find different ways of achieving a better outcome with less effort.

Interaction

This topic follows the same kind of bell-curve progression as the ceremonies.
Immature teams shy away from communicating with each other or the Product Owner. Developers somehow try to progress individually. Especially the Product Owner has very little touchpoints with the team - except for Planning and Review.
Mature teams communicate constantly with each other and the Product Owner. No question is too trivial or too difficult to ask - what counts is building up a common understanding. The team probably wouldn't even miss the PO during Review, as they already know the PO's shot at their results.
Really mature teams have a high degree of common understanding. Discussions start to center around  synchronization and innovation. The overall need for discussion might decrease when work is easy to modularize.

Summary

Look at these six patterns: Problem solving, Collaboration, Getting things Done, Process change, Ceremony Behaviour and Interaction. This will give you a fast and thorough understanding of how mature your team really is. You can adjust your own behaviour as a Scrum Master to accommodate the needs of the team.

What does a Scrum Master do during ceremonies?

I was recently asked the question, "What does the SM actually do in Scrum meetings, apart from facilitating" - so here is my view. It coincides with what I do, not with an absolute stance of "This has to be like this".


As Scrum Master, there are different modes I take during a ceremony. My "mode of operation" depends on the team's condition. My indicator of choice is maturity, which I consider a mix of ability, autonomy and motivation.

Teams of low maturity

Understanding of ceremonies is low. I'm lucky when the team even understands why we have the meeting, much less what is an effective way to get the necessary outcome.
Maybe I even need to start with a detour, explaining the purpose of the meeting, the approach and intended outcome. As facilitator, I dig into my stash of facilitation tools to keep the audience both focused and engaged.
Engaged groups don't need to be whipped into action, so my most important job becomes timekeeping. I like to give strict timeboxes on each activity, furthering the mindset "It's not about coming up with a perfect plan - it's about doing the best thing we can do within the available time."

For really immature teams, I will facilitate everything. I "give the voice" to people who want to say something, I sum up the outcome, provide a photo protocol and ensure that someone takes accountability of decided follow-ups.

In cases, where teams even have less subject matter expertise than I have (indicating that they are "stone age"), I might even involve in discussions by providing potential alternatives they can explore and cutting off rabbit trails.

From a leadership perspective, I will provide clear direction on the ceremony form and necessary guidance on content.

Slightly advanced teams

When teams already have a basic understanding of the ceremonies, I don't need to state the obvious. I might use a Refocussing Question, "Why are we doing this ceremony?" as an opener to start the ceremony and raise awareness within the team.
At this level, I don't facilitate as much as I moderate - providing a proper environment for the ceremony to take place and ensuring that the team has the necessary means to reach their goal.

I still take control over keeping the agenda by applying moderation techniques that help the team to reach the next point autonomously. I will hardly intervene. My main intervention will be an occasional thought provoking question to open up different alternatives.

From a leadership perspective, I will provide guidance on the form and support on content.

Matured teams

A matured team doesn't need me to do things for them anyways, so why would I? They own the meeting.
Of course, they might ask me to actively facilitate - for example - hot topics they can not reach consensus on. In these cases, I will support based on pull-principle. Other than that, I will sit back during their session, reflecting on the meta-situation.

I will mostly be looking for things happening that those who discuss are not aware of - such as people suddenly withdrawing, someone taking control over the meeting, elephants in the room and things. The insights I gain may or may not be necessary to help the team grow. It depends. When I observe a severe dysfunction, I might intervene with a question like, "Is there a specific reason you've abandoned Tim's idea?" and otherwise leave the field to the team.

After the meeting, my insights provide the basis for reflection among the team, either on an individual or collective basis.

From a leadership perspective, the meeting is fully delegated to the team - I provide vital support on demand or when inevitable.



Side note on leadership

The underlying model is direction-guidance-support-delegation, moving further with increasing autonomy/ability/motivation.

Summary

What I do depends on need. I spend time not only to conduct the meetings with the teams - I also invest into transferring understanding and ownership towards the team. The team themselves needs the outcome and when they have learned effective ways to obtain that outcome without assistance, there is no need for the Scrum Master to impose anything. Over time, the Scrum Master becomes more of a reflection beacon than an actor.

Getting to that point can take a long time. In an "orange" organization, this is definitely much harder to attain than in a "Teal" Organization.

Is SAFe just another name for Waterfall?

A strong accusation against SAFe is that it's only a different name for "Waterfall", i.e. while the structure and names are different - the underlying process (and corresponding problems) remain unchanged - so let's clarify how SAFe really changes your development process.

The Waterfall

Does SAFe permit you to continue running a dysfunctional Waterfall? The classic "Water-Scrum-Fall", a widely spread phenomenon:

The Water-Scrum-Fall: "Agile" is something else.

 Can you do that with SAFe? Yes. Then again, you'll be hard-pressed to find any type of statement that SAFe is actually encouraging this. So - why do people think SAFe is just Waterfall reloaded?

1. The PI Planning

As described in another article, the reason why there is a "PI Planning" is not to maintain the Plan->Build->Run cycle (aka. "Waterfall"), it is to create common understanding. PI Planning does not separate "planners" and "doers": Given a prioritized list of abstract, high-level stories ("features"), they decide autonomously what to do while exploring the "Why" together with others. The detailed "What" and "How" is deferred to the latest possible time where it makes sense - i.e. the Iteration (Sprint) Planning of the iteration when teams actually get around to the topic.

Highly empowered, autonomous teams make their own decisions regarding "What", "When" and "How". Managers serve as facilitators, not as authors. Teams propose the most feasible ideas. Teams agree with each other on the objectives. The output is a prioritized, value-based list of objectives for the overall PI - and an intitial short-term backlog for each team. Everyone knows full well that the backlogs can and will change, both in content - and in order. The teams commit to work towards common goals, not to complete specific activities.

PI Planning can not be compared at all with classic project planning.

2. Three-month increment

One of the biggest gripes with Waterfall is Three-Month (or slower) release cycles, inherent to the system: Typically, a stressful analysis phase is followed by a painful development phase, culminating in an excruciatingly painful test phase, where developers are fixing the problems of the current release while already working on the next release.

SAFe operates in small, integrated cycles and suggests applying Test-First implementation. As discussed in an article about releasing, SAFe builds on "Deliver Anytime", taking advantage of fast, integrated learning cycles. Creating batches of work, then sending them through a development process pipeline is not part of the SAFe model. In each Iteration (Sprint), teams refine, plan, build and deliver individual stories and small portions of value. There are no separate "Analysis / Development / Test" phases in SAFe.

A SAFe team should preferrably be arranged to be cross-functional, allowing a single team to ideate, design, implement and verify customer value autonomously. This reduces Work in Process (WIP), handovers and delay.

The PI Increment can not be compared with a Quarterly Release as the underlying process is not the same. 

3. Systems Team

A specific team deploying and operating the built product ("Operations") is a common pattern in Waterfall organizations. The consequence is a "throw over the fence" attitude ("works on my machine") and animosity between developers and operations.

SAFe strongly encourages DevOps practices, bringing the responsibility for operations directly into the teams. The buzzphrase "You build it, you run it" is also applicable in SAFe. Throwing stuff over the fence is not encouraged, as this creates communication gaps and a desync between work in progress among teams.

Then - what is the purose of the Systems Team?

Infrastructure
Teams are potentially challenged to provide a well-working delivery infrastructure, such as deployment pipeline and operating environment.
Especially early on in a transition, it makes more sense to have specific experts deal with infrastructure so that development teams can get around to deliver value and not constantly be distracted by working on base technology. As the Agile Release Train (ART) matures, the infrastructure stabilizes and the amount of maintenance work should decrease to a point where teams can handle it.

Solution Testing
Although this should not happen, occasionally developers or large systems are so focused on their work that they lose sight of the overall process. The question "Who maintains the Big Picture?" sometimes remains un-answered. In cases where developers work on individual microservices and lose sight of the end to end customer facing processes, there needs to be someone to ensure that the customer can actually use the new increment. This may require both exploring the product and automating standard test scenarios. Similar to the point above, as the ART matures, the amount of necessary manual oversight and undone test coverage should approach zero.

Long story short: The Systems Team is not doing work in a different phase. They do work that is outside the other teams' Definition of Done.

Summary

SAFe requires dramatic changes to the way developers work. While not everything is different from how things were done in the past, an ART works radically different from Waterfall. How massive those differences are - depends on how agile the teams are. Maturity and autonomy are the keys to success.

The idea behind SAFe's PI Planning

One of the key ceremonies in SAFe is the "PI Planning", where teams come up with an aligned plan for the next 6 iterations. Why do we have this special ceremony?


Let's start with the reason why SAFe's PI Planning has been designed, and what happens during PI Planning:

1. We don't plan for others. The teams create their own plan. Handovers are discouraged.
2. We don't plan activity. We plan objectives. This provides enough transparency for everyone. 
3. We don't schedule the details. We sort the objectives in descending value order, then put the most valuable thing first.
4. We don't focus on having a plan. We focus on achieving a common understanding. Unexpected things happen and our estimates are usually misleading. That shouldn't stop us from having a thorough discussion about what, why and when.

Objectives over Stories

More important than defining the individual backlog items (i.e. user stories) is the definition of mutually agreed upon objectives, i.e. what the teams desire to accomplish - and why their work contributes to the enterprise goals. 

While stories are created for features during PI planning, the main purpose of stories is to discover the scope, range and purpose of the feature in collaboration within the teams, with Product Management - and Business Stakeholders!

The Stories that are created are then summed up in terms of objectives, i.e. outcomes that the teams want to obtain. The value of these objectives is discussed in business terms, with the intention that developers have a clear understanding of why certain goals are more valuable than others.

This shared understanding of common goals is probably the most important output of the PI Planning, because it keeps expectations closely aligned in the following months.

Catch inconsistencies

When teams place their objectives on the Program Board, this forces them to consider whether their objectives are consistent: within themselves, with each other, with those of other teams, with time available, with extrinsic factors (such as: market constraints, vendor delivery etc.). With simple red strings, the Program Board shows dependencies - which themselves are pointers to a high risk of becoming inconsistent.

The visualization of planning inconsistencies helps teams to steer clear the pitfall of inconsistent delivery later on. 

While a part of the purpose created by the program board is indeed to get a clear understanding of what will be done roughly when - the biggest value is to have a consistent big picture, shared by everyone on the Release Train!

Planning horizon

A big question for many agilists is: "Why do you plan 3 months ahead?" - This has mostly to do with U-Curve optimization. 

We don't do this because we consider it's a good idea, it's more likely the most feasible thing to do, especially in environments with distributed teams. Our goal is to minimize batch size. 

For an organization that is currently transitioning from a legacy development model that has a more-or-less expressed backlog for the next couple years, moving from a "We just do what we feel needs to be done" towards "We know exactly why this thing is Priority 1 and how we can contribute" is a massive leap forward.

Think ahead

The 3-month planning horizon creates a slowly depleting team-levelbacklog for each team. Based on the one central product backlog, every team backlog has been clearly optimized to maximize the value this team delivers. When a team fails to meet their objectives, they have a clear understanding of the value gap - and can use this to communicate with other teams to maximize overall value delivery in a delivery Inspect+Adapt.

The team backlogs are not exhaustive. They contain value-ordered lists of those stories that are known upfront. The teams still refine their backlog continuously throughout the PI. Items from the backlog may be added or removed as new information becomes available. 

The defined PI Objectives help the teams place new items into an appropriate position in the backlog and provide a useful guideline for value delivery. Within the scope of the defined objectives, the teams gain full autonomy on how to build things without the need for frequent synchronization and coordination meetings.

Optimizing PI Planning

There are two questions we should ask about the PI Planning horizon:

1. How can we reduce the overhead associated with planning - so that we can plan together more often?
2. How much value do we lose by having to resort to mid-term planning - and what can we do to decrease the value decay?

If you can get all the teams to plan together every month or even every Sprint, then by all means - do that! The planning periods will be shorter, product value will be higher and mutual understanding will be better.

Summary

SAFe's PI Planning is the first step in an evolution away from Big Upfront Planning, with the intention that teams gain full control over their work, while providing the required stability for effective, valuable collaboration. 

As your organization becomes more agile, PI's might become more fluent and iterations shorter. As mutual understanding grows, the need for clarification will decrease. Plannings become smoother and faster over time. 

As you learn how you can maximize the value of planning, the nature of your PI Planning will adapt accordingly.

What will remain is the need to have a common understanding by planning together frequently.

Why project organizations are doomed

We talk a lot about why we should shift from organizing around projects to stable teams. In Scrum trainings, we use the Stacey Diagram and explain the need for agility with the inevitable Unknown that we encounter. From that we conclude that Waterfall projects with pre-planned structure and approach are doomed to fail. The basic assumption can remain intact that if we had more certainty, projects would work out. And so, we basically still assume that project work is fine - as long as it's done in an agile way. In this article, we will discuss that a project organization is doomed - agile or not. You have no choice except to change how you organize.

Prelude

The Want-Need-Matrix

Let's start out with a simple matrix I borrowed from Marshall Goldsmith. Well, I took the liberty of simplifying it even forther than described in his book, "Triggers", because it's enough to serve our purpose for this article:

The Need-Want Matrix

On the vertical axis are Wants, on the horizontal the Needs.
In the top right we see: We need and want success. To not open up a barrel, I am not defining "success" in detail. It can mean different things to different people. Whether that is recognition, money, gratitude or whatever - we long to have those things, and we need them for our own well-being.
On the upper left, we have what we want, but don't need: distraction. In this case, anything that distracts us from success. The worst kind of distraction is instant gratification, ignoring long-term success to have a temporary High right now. Arguments are another distraction: Fault-finding without problem solving distracts us from proceeding.
On the lower left, we have what we neither want nor need: trouble. Trouble is the opposite of success - distress, losing money, being shamed, ostracized or whatever.
Nobody really wants rules. We just need them to prevent trouble. And they help us keep on track, so that we can achieve success.

The Vicious Circle 

The vicious circle: Distraction, trouble, distraction ... it never ends!

Distraction wouldn't matter nearly as much if it had no impact. This is rarely the case. Typically, the result of distraction is that something slips. And when something slips, that means some kind of trouble. At the minimum, we need to catch up. Or we start making excuses - which only end up causing further trouble. Once we're in trouble, we typically try to get out of the troubling situation. The easiest route is displacement activity - yet another distraction. And so, we end up "fixing" the problems caused by distraction with distraction. Now, how do we get out of that?

The virtuous circle

Moving to success requires rules

Once we're in trouble, we can deflect - or we can improve. We typically set rules to avoid the distraction that caused the trouble.
It hardly makes sense to create rules for every possible distraction, so rules are typically reactive. We see the virtuous circle: We got distracted, we took the hit, set a rule and move forward. Like this, we constantly improve.

Don't take success for granted

What got you here won't get you there!

Be alert: Just because you're successful, doesn't mean you remain so. At any point in time, even currently successful people can run afoul of falling into distraction. There are many reasons why this may happen. One of them being that your environment changes constantly - and that means that today's success may be tomorrow's failure. By continuing to do what you did previously, you might actually be distracting yourself from succeeding in the future!

Keep your rules updated

Sticking to helpful rules keeps you on track

By keenly observing our rules and updating them as necessary, we remain in the success dimension and avoid distractions, consequently - trouble.

Adverse Rules are devastating!

Adverse rules that prevent success!

Sometimes, we set up rules that not only don't prevent trouble - they prevent success and cause the trouble we're trying to prevent!
Once we have adverse rules in place that we can not simply break, our only way of avoiding trouble is to remain in the "Distraction" quadrant.

The problem of projects

A project is usually defined as a specific endeavour to be accomplished within a specific time at a specific cost. Companies do their best to align project objectives with business goals, and therefore, overall success. Then, they task a Project Manager to meet the project objectives - deliver the defined result in TQB.

Same goal, different goals

While the project's stated goal is part of the corporate goals, the goals of the project are not the same. The goal of the project is not to succeed as a company - it is to meet the predefined objective in TQB. The so-called "Iron Triangle" is usually a bit softer in one or two corners, and a Project Manager will optimize to meet the Primary Objective (i.e. deliver on a specific date - or prevent budget overrun) at all costs.
Suddenly, the presumed goal (the Business Objective) is replaced with a different goal - meeting the Project Objectives.
We call this a "distraction", and now our project organization is directed towards a distraction.

Favorable rules, adverse effects

A Project Manager is always expected to do their job properly, i.e. deliver the stated objective in TQB. As their success is based on their Primary Objective, they will create a set of rules to ensure their Primary Objective.
When a developer within the project has the option of working towards the business goal, in conflict with a Project Rule, the developer will be constrained by the project rule. The rule becomes an adverse rule from a systemic perspective.

Perverse incentives

Project rules typically include things like status reports, status meetings, timesheets and many other things. Breaking any project rule will trigger a project investigation, putting the developer's behaviour under scrutiny. This means that the developer will have even less time to work towards the business objective - which means they are in trouble. To avoid breaking adverse project rules and ending up in trouble, developers can only follow project regulations which are a distraction from business success. 

Staying out of trouble by causing trouble

As we discussed in the Virtuous circle, when a distraction is encountered, the only way forward is to accept the trouble and improve the rules. When adverse rules are cast in stone, moving into trouble is no progress. A developer has no option of getting out of the trouble domain, except by staying out of the trouble domain in the first place. Being in the distraction domain, the only way of not getting into trouble - is by staying distracted!

The consequence of distraction is trouble, and so people are shoving a whole bunch of trouble under the rug, hoping it will never surface. Business success is far out of reach.

Summary

Project organizations suffer the malady that a project has it's own goals, which distract from business goals. The rules that create a project structure result in a condition where distraction, i.e. avoiding business success, is the only desirable state that can be attained - even when the project runs perfectly!

A company can not succeed until they break this vicious circle. This means they need to abolish the rules required to run a project organization. This means that the project organization will no longer function.

Failing with a project organization is not the fault of project managers or those initiating the projects. It is an involuntary side effect of running projects.

You need to move away from project oriented structures towards product oriented structures as soon as you can.

How SAFe approaches releasing

While a Program Increment spans 3 months, While at the end of these 3 months, there is a "Solution Demo" where all Release Trains demonstrate a Working Product, SAFe suggests "Release Any Time". This is not to be confused with "Release at the end of every increment". Let's clear up what the intention is.

Developer perspective

One of the biggest plagues of Waterfall software development is the "Integration phase", where developers bring together the different pieces of work and try to patchwork it into a shippable product. Martin Fowler described "Integration hell" and the corresponding solution, Continuous Integration, a long time ago. SAFe suggests applying Continuous Integration, combined with scrutinous test automation, on a developer level.

Every developer should aspire to keep the product shippable at any time. After every commit, the product should be "done" in regards to the work invested up to this point. There is no place for "loose ends".

Team perspective

Every team works on their specific stories and objectives. Whenever developers feel that they are ready to deliver a specific piece of work, maybe even just a fragment of a user story, it's up to the team what to do with the result. SAFe encourages delegating Micro-Decisions, such as whether to release the new "Search" function for our Website, directly to the teams doing the work. 

In the same breath, teams should have both the authority and technical capability of delivering their value when they feel is the right time. Continous Deployment is a wonderful way of accomplishing this wherever possible.

Release Train perspective

The Release Train, a "team of teams", builds Features - major blocks of customer value. In some cases, these features do require a lot of upfront work and big-batch releasing. For example, "The new iPhone" requires "a new iOS", "a new battery" and "a new chassis": You can't just deliver the new battery whenever you want. It's just a new feature that has no market value until it can be integrated into a shippable product. And this "integration" is not just software level. It includes setting up a physical production chain - and potentially tons of legal paperwork that could take months to complete: That's just not what you do 27 times a day.

The decision to insert a completed major feature into the current product is beyond a single team's sphere of control. The Release Train must be ready and overall willing to deliver the product with this new feature. This does not mean that the date is either preplanned in complete disregard of development reality - or that the feature sits as inventory until a PI end date is reached.

This is where PI planning is a major boon: When teams need to collaborate on big batches, it does make sense to put the product milestones onto a common plan, so that everyone knows what needs to be done by when.

Value Stream perspective

In some cases, the product development is so massive that multiple Release Trains need to collaborate. Resorting to the example that Mike Cohn also uses, of developing an Office Suite, the Train in charge of the Word Processor can't simply decide to release "The New Office". They can deliver features into Word, they can deliver bugfixes - but they can't control the entire campaign surrounding Your Office.

Decisions to bring new Capabilities to the market are made on the level where the different trains in the same value stream come together. While product releases are made completely independent of cadence, the Solution Demo is a good way to give and receive feedback regarding whether it makes sense to proceed with releasing.

Portfolio perspective

In exceptional situations, even a completed product needs to be kept off the market for maximum effect. There may be strategic appointments defining when a product needs to hit the market - no sooner, and no later. In these cases, even the Value Stream has no influence on releasing. An example could be a government contract to deliver a new Public Security Monitoring application. While demos, piloting or potentially even localized initial trial runs of individual features and capabilities are well within the ability of the teams, trains or value streams - releasing a major milestone into the market comes with a lot of media buzz and the potential for devastating repercussions. 

In such extreme scenarios, Epic batches may need to withheld from official release despite internal agreement that go-to-market is possible.

Summary

Releasing in SAFe follows the 9th Lean-Agile principle, "delegating decisions to the lowest possible level" - encouraging the release of value at the earliest possible date where it makes sense, reaping value as soon as possible and maximizing opportunities for feedback learning. SAFe does not  encourage big batching, yet it provides a clear approach to dealing with situations where batching is inevitable.

Common misunderstandings of SAFe

SAFe is becoming increasingly popular - and with it's popularity, we encounter the issue that people with a superficial understanding harbour inaccurate concepts about what SAFe is or does. Here, we want to debunk a few of the most common misunderstandings. There are also others, which we will discuss at a later time. 

#1 - SAFe is too ...

A common issue around SAFe is that allegedl, people consider that it is ...

• Heavy
• Complicated
• Complex
• Restricted
• Restrictive

Regardless of which of these are bothering you, first consider the following: SAFe is a framework intended to aid you on the journey of developing highly complex systems in a dynamic marketplace. If you can do that with a single team, then - by all means, do that. SAFe is not a way of making simple things complicated.
When you are dealing with a complex, adaptive system, then any simple solutions will be snake oil - based on wishful thinking. SAFe does not claim to dissolve the inherent complexity. On the other hand, it reduces the unnecessary complexity induced by legacy organizational structure.
SAFe does become restrictive and constraining when it comes to structure in the same sense that Scrum does. SAFe discourages bloated, inefficient structures without customer value. In SAFe, there is no place for complex reporting processes, time-squandering status meetings or wasteful accounting structures.
SAFe encourages optimizing structure and processes constantly, applying Lean and Agile principles. Many people say that SAFe, at it's core, is really just plain common sense, even "too obvious to be special". Except that too many organizations don't apply common sense - and don't see the obvious.

#2 It’s just another name for Waterfall

Common arguments include:

• Each PI is a Waterfall
• SAFe is just another PMBOK style waterfall.
• It’s just RUP Reloaded

The basic premise of the Waterfall is a phase-based model, where analysis is succeeded by design, by development, by test, by releasing. While SAFe considers all of these activities as useful, it neither prescribes doing any of them in a specific fashion - nor does it suggest these be done sequentially with an implied handover process.

SAFe supports the continuous delivery of Working Products, within each PI - within each Sprint - and within each team. SAFe's delivery model is highly inconsistent with a phased model.

The PI is an abstraction layer of an iteration. Unlike a traditional program, there are no phases assigned to Increments. Every Increment results in a Working Product Increment, and at the end of each increment, the "Proceed/Stop" decision is based on inspection of valuable deliverables. Artifacts like documentation or un-integrated code are not considered value.

While SAFe has so-called "Programs", a SAFe Program is not a classic large-scale Waterfall project. A SAFe program is, first and foremost, a larger group of people working together towards a common vision. It does not imply sequential phases or separations of concerns.
SAFe has specific suggestions how to get started and be successful in a very short period of time, the key idea behind SAFe's program structure is this: As organization size increases, non-value added coordination also increases (i.e. anti-scaling). Therefore, SAFe suggests an organization both in terms of structure and process which significantly reduces non value adding coordination.

SAFe does permit you to integrate with a Waterfall organization either on lower or higher levels of abstraction, yet this type of integration suffers from the same maladies as a Scrum team would suffer when being forced into a Waterfall mode of delivery. SAFe intergration with Waterfall is possible, albeit wasteful and extremely risky. Both the waste and risk are endemic to the Waterfall and transferred onto SAFe.
SAFe encourages abolishing Waterfall structures as fast as possible and suggests converting the entire Value Stream towards SAFe in order to minimize the impact of Waterfall practices.

#3 - SAFe doesn't fit

People are quick to dismiss SAFe before understanding how to fit it into their organization, for example:

• We are too big / too small for SAFe 
• SAFe has to be tailored to fit
• We have to modify SAFe so that it works
• SAFe processes do not fit into our organization

Let's start by stating the obvious: SAFe is a scaling framework. When you can avoid scaling, please do that!
Even when you aren't really scaling, the SAFe values, SAFe principles and SAFe mindset are useful. Of course, you won't be using SAFe structures and processes to solve a non-existant problem. SAFe is a way to approach the problems you already have and it's excruciatingly good at highlighting where they are.

When it comes to "too big", SAFe is probably the framework that has proven to work with the largest organizations of all scaling frameworks. The Value Stream layer, introduced in SAFe4.0, basically allows you to organize thousands of developers working on the same product. If you think you go beyond that, it is more likely that you only think you need so many people because your organization is so ineffective - not because your development challenge is so big.

There is significant danger in modifying/tailoring SAFe: SAFe follows the Shu-Ha-Ri learning principle. At first, do the motions until you understand - then you adjust the practice to get better results - finally, you transcend everything to obtain the same outcome without the initial motion.
For companies new to agile, it is highly recommended to first learn the basics before jumping into modifications. Just like in Karate, you don't go into a Dojo and tell the Sensei "Well, I like this Karate thing - but we need to modify it a bit so it suits my needs" - you need to get a grip on SAFe before meddling with it. The odds that you are modifying something that is actually essential to success increase with lack of understanding.
An expert agilist would definitely approach SAFe differently from a beginner, yet it is often self-proclaimed "experts" that do the darndest things.

SAFe has been proven to work in thousands of companies across the globe, spanning all kinds of industries. While it is possible that your company is such a special case that you just can't make use of SAFe, chances are that in these cases, neither is any other agile framework, including Scrum or Kanban.
Most likely this means that your optimization goals are not compatible with the following common optimization goals: Value, Time-To-Market, Customer Satisfaction, Effectiveness, Learning. In that case, SAFe has nothing to offer.

Some organizations are already so agile that SAFe is a step backwards. Congratulations! You're already in the top 0.1% of your industry! Keep it up. We'd like to learn from you. You may still refer to the vast experiences collected by SAFe to get some ideas and simply grow and improve on what you're doing.

#4 - SAFe isn't real Scrum!

Here's some common statements:

• SAFe does not include Kanban/Scrum
• SAFe dilutes Scrum/Kanban
• SAFe doesn't support Continuous Delivery

Let's start with the simple things first: SAFe encourages using Scrum or Kanban on team level. Unlike Scrum itself, it's not prescriptive in stating "You MUST do Scrum or you're doing it wrong!!!!11oneoneeleven". When teams are more comfortable with one or the other, they have options. SAFe is equally compatible with either. SAFe's main constraint here is that the teams need to be able to integrate continuously and should be cross-functional.
While this implies that it's possible that you have a SAFe implementation without Scrum at the team level, SAFe actively encourages at least trying out Scrum first.

A little more challenging is the topic of "diluting Scrum". There are modifications to Scrum, based on the idea that a team is not fully autonomous when they are merely a component within a complex system. Pure Scrum has nothing to say about the interaction of teams when interests are in conflict. SAFe redefines the Scrum Master as focusing more on the team, accepting that issues within the organization at large might overburden the Scrum Master.
Scrum equally has no suggestions when the product itself is so big that one PO can not both maintain the entire product and be sufficiently available for all teams. SAFe attempts to provide a meaningful way forward, stating that final product decisions are - just like in Scrum - single person (not committee) decisions, effectively de-valuing the PO role as product/value focussed person within the team - putting a PM in charge of what we'd typically call a "real Product Owner".
The principles and values of Scrum are retained. Similar statements would apply when a team chooses to apply Kanban, except that SAFe purposefully considers the roles of Scrum Master/PO vital to team success - so SAFe suggests having PO/SM even when teams use Kanban.

Continuous Delivery is clearly supported by SAFe, as are other XP practices. While SAFe accepts that for some organizations, Continuous Delivery is still a huge stretch, SAFe encourages these companies to set "Be able to deliver any time" as a key goal for value creation.

#5 - SAFe isn't Agile

Some people claim that SAFe does not manifest agility. The arguments are these:

SAFe equals Big Bang releasing

SAFe is Non-Agile and doesn't support the Agile Manifesto.

The "But it's not agile" guns are quickly pulled and fired, in classic Western Style "Shoot first, ask later".

SAFe acknowledges that large products, such as "The new iPhone" are typically released as major updates, including big and costly upfront marketing and sales activity. At the same time, SAFe encourages the continuous, fast delivery of value both for commercial and innovation reasons.
Regardless of which approach to releasing is suitable for your specific product, SAFe is fine with that. While frameworks like Scrum are completely neutral regarding large-scale effects such as "Super Bowl", SAFe suggests putting major commercial events on a calendar, then planning potential scope around these events to leverage maximum business value. This idea is not conflicting with the continuous and early delivery of value.

In regards to the Agile Manifesto, SAFe emphasizes the Agile Manifesto equally - or even more - than frameworks like Scrum or Kanban. While agility at scale is significantly more complex than team-level agility, SAFe acknowledges that both the values and principles of the Agile Manifesto are valid. A thorough understanding of - and support for - agility is a prerequisite to succeed with SAFe.
A culture that does not support the Agile Values will not succeed with SAFe. Let's just be brutally honest here: That kind of culture will not succeed with agility regardless of framework or approach.

Conclusion

Well, that was round 1 of SAFe misunderstandings. There are more to discuss later.

SAFe does not claim to have all the answers. SAFe is a good way to get started on your journey to Enterprise Scaled Agility, and "Here's something you can try" is better than "Well, you have to find out ..." for many people. After introducing SAFe, you will constantly inspect+adapt to discover better organizational processes and structure.

Think about why you hold specific reservations about SAFe. Maybe the problems are caused by your perception of SAFe, not by SAFe?

Denying requests without saying "No"

My recent post about why saying "No" or "But" might be avoided spawned the question: "A Product Owner should better say NO quite frequently". Based on my experience, here are some tips for a Product Owner to deny a request without actually resorting to "No". I've been using these kinds of statements for years, so this is a small collection of keeping your product in shape while staying positive.

How exactly does this idea fit into our long term strategy?

Any request which is not yet in the backlog is not worth considering in the light of the current strategy. The burden of proof to the contrary rests on the stakeholder rquesting something new.

The Product Owner should be very clear about the product strategy. Requests that either conflict with this strategy or are irrelevant to the strategy have tremendous impact. While the PO can explain the current strategy to the requester, it is the responsibility of the requester to convince the PO that this item will actually support reaching significant strategic goals faster. Tools like "Impact Mapping" are great ways of doing this visually.

You just need to convince the other stakeholders. 

"Can you ask the others to approve your request before I do something that conflicts with theirs?"

Especially in corporations, there are often many stakeholders with conflicting interests. As soon as the PO puts an item into the backlog at a certain priority, they need to justify to all of these parties why this item has been placed there - especially since it means that all stakeholder requests of a lower priority will be either deferred or descoped. Why would you want to be in that position? Just let the requester go into the line of fire. Tools like "Buy-a-feature" may be invaluable to do this effectively.

This is probably going to cost you about 10x as much as you'd want it to.

"I just asked the team, this is much bigger and more expensive than you thought".

Random ideas can quickly congest the path on your journey to maximum value. Often, stakeholders have little or no understanding how much work a "small favour" actually causes. Since the PO also doesn't have all of the information, it is very risky to commit anything behind the team's back. I have experienced "just a few days" items become severely impactful on strategic milestones, and that's not something you want. The most effective way to avoid cost/effort/timeline traps is applying the very simple tool "Ask the team".

We have limited WIP.

"Which of your requests should I scrap in order to put this into the backlog?"

People are good at coming up with ideas to keep others busy. Many people are just very bad at understanding that WIP Limits are pretty much essential to keep getting things done and delivering a valuable product. You need to exercise caution to avoid becoming a "request manager" tracking endless lists of things that have no chance of ever getting done. You don't want become responsible for reporting status of items that aren't being worked on - and you also don't want to justify why you're not getting more things done than the team can do. Make it the responsibility of the stakeholder themselves to get gray hairs over figuring out which things they really need.
A very simple tool is to have a Visual Dashboard with strict WIP limits. If that doesn't help enough yet, assign specific WIP limits to each stakeholder - for example, 3: Requests are only accepted once something got done.

Our backlog is a prioritized list.

"Do you have any data that warrants putting it into a position where it has a chance to be done in the next half year?"

Why should you, as Product Owner, waste your precious time to figure out whether something is worth doing when even the person making the request can't be bothered to do that? You are a bottleneck. Delegate as much work as possible. Avoid feeling pressured to put something at Priority 1 just because the Group CEO just had another great idea. Arrange your backlog items so that they make sense from an economic perspective. You can keep items off the list that aren't healthy for the company with the tool "WSJF" (Weighted shortest Job First).

Based on the current state of the backlog, this has no chance be done anytime soon.

"It won't be done within the next half year. I suggest you come back in about 5-6 months, if it's still important."

Why would you even bother to track things so far into the future that it's more likely your product won't fit to the idea any more than seeing these things actually get done? If the idea is good, it will come back later. If it isn't - well, why is it important to keep?
Once a request is not sufficiently valuable to get done anytime soon, it is very likely that this is the actual value of the idea. As our product grows, our ideas should actually get more valuable over time - so ideas that already aren't valuable enough now will probably never be. By keeping a rough idea how much work is currently in your backlog, you get a rough idea when the item at position 20/30/50 will be done. Any item moving to the bottom of the backlog, being beyond a predictable horizon, wastes your capacity as you need to think about it all the time.
You make your life as PO significantly easier by capping the backlog size to contain roughly 1/2 year of work.

We discuss things when they become important.

"We will consider your suggestion at an appropriate time. Thanks."

And 'now' is not that time. This means nothing short of 'This item is wasting my time', it's just phrased a little more polite. 

At any time, the Product Owner should maintain focus on the top few priorities in the backlog. Anything that is not there reduces the odds of success - who would want that? 

Avoid getting dragged into meeting madness for things that may never happen. If others want to discuss these things - fine. Let them. Once they have overwhelming evidence that you should invest time, go ahead. Until then, feel free to assume that your product is doing perfectly fine without adding the request.

Resort to Backlog Weeding. Treat all ideas that aren't worth doing anytime soon as weeds.

Summary

Being a Product Owner and staying positive towards all requests is always a tightrope walk. 

Use the approaches and tools described in this article as stepping stone towards respectful product ownership in challenging environments.

Three words that poison every conversation

Nearly a decade ago, my Change Leadership trainer already taught me a valuable lesson: How a few simple words can destroy meaningful communication: "You're right, but ...", "Yes, but ..." "But you need to see ...", - the memo stuck: "Get your But(t) out of my face". Not until I read Marshall Goldsmith's "What Got You Here Won't Get You There" did I start to become conscious of how often this phrase and others are used.

A small dose is enough to poison the conversation.

But, No, However

Marshall pointed out all three terms as ways to turn any conversation into some sort of war. When I first read this, I remembered the good advice I received so long ago - and started to monitor these terms and how they are being used.
They are toxic because all three of these terms have the same meaning: "I know something you don't - I am better than you." The healthy exchange of ideas on face level becomes blocked as soon as one person starts elevating themselves above the other. What follows is often a toxic vindication of standpoints.

Why do we say these words?

Few people actually mean to poison a conversation. When I first started looking at myself, I became conscious of what I was doing. Maybe you want to re-read my blog articles with this in mind. You can pinpoint fairly exactly when I started reading Marshall's book. Before that, I was simply unaware of my own use of language. I never meant bad. I was simply un-aware. So, when you realize you're but-ted out of a conversation, the next thing you should realize that this is most likely happening because the other person is unaware of what they are doing.

What to do about it?

For me, it became a tedious exercise of monitoring every single sentence I wrote. Whether it was a blog post, a LinkedIn reply or even a simple mail response, I started double-checkeing. I re-phrased every sentence I had poisoned. I am still doing this today. Do I still use these words? Yes. What I do try is to use them consciously, when needed. Does it make sense to avoid answering a binary question directly? No. See. You got me. I did it on purpose. I know what I did - and why I did it. I had a chance to reflect on my own words to improve my own communication.

How about spoken language?

Written language is significantly easier to monitor than spoken language. When I first started observing my own speech behaviour, I was all full of the first and second, resorting to the third in a feeble attempt of evasion when I caught myself. Learn to think twice before speaking. Form your answer in your head. Be a bit more constricted on the words you let out of your mouth. Change is hard. You will fail. More than once. Getting better requires being conscious of what you do - and not being too hard on yourself. Just sufficiently hard to avoid falling back into old habits.

Conclusion

Do your conversation partners a favor. Eliminate the toxins of "No", "But" and "However" from your vocabulary. Start becoming a more amicable communicator today!