Investment Portfolio Management Applied to Product Management

I've been telling myself that I needed to attempt to apply formal investment portfolio management techniques to how we value, prioritize and manage our portfolio of product development efforts, so here goes (definitely still a work in progress)
Back in 1950's Dr. Harry Markowitz created an investment model called the 'Efficient Portfolio'.  Markowitz stipulated with his theory that an "Efficient Portfolio is one where no added diversification can lower the portfolio's risk for a given return expectation (alternately, no additional expected return can be gained without increasing the risk of the portfolio)".
The Markowitz Efficient Frontier is the set of all portfolios that will give the highest expected return for each given level of risk.
 
This model set the framework for how current money managers build a portfolio of securities that provide range of investment returns to meet each investors risk profile.  Providing investors with a broad range of risk/return choices allows individual investors to build an investment portfolio that meets their specific risk threshold with respect to a given rate of return.
An efficient portfolio looks like this:
 Efficient Frontier
When you are younger and have time to take chances your risk/return profile might be higher on the frontier, whereas at retirement you will slide down that scale as you are more interested in protecting your total investment.  One thing to note is that if your risk/return data falls above the efficient frontier, then you are accepting a level of risk that is not in line with the rate of return you might receive.  Pushing past the efficient frontier can open you up to unexpectedly high returns but conversely you can also expect very high negative returns due to the risk you are taking on.
Product Development organizations can utilize the Frontier as well, for example, a young startup will have a much higher appetite for risk as they understand that to take market share from competitors they need to take risks with speed to market.  However there are specific elements of risk that need to be considered as you speed your product to market.  Ensuring that Usability has been considered, Prototypes have been developed, code quality is considered and test automation all need to play part when you are building your risk/return Efficient Frontier for your Product Portfolio.
If we were to apply the Efficient Frontier to how we manage our Software Development investments we could build a risk/return profile that is easy to understand and align with the organizations risk/return profile.   There are many software projects that at inception are known to be risky, however a lack of empirical data often means that the projects will get the green light and then fail miserably.  The organizations inability to accurately asses risk/return at any time with their software development investments is a huge blind spot and keeps us from consistently delivering the value that the organization needs to stay competitive.
Agile addresses the value (return) part of what the Efficient Frontier speaks to however it talks nothing of Risk overtly.  Risk is more implied with the notion that we manage it by delivering in short increments and focus on shipping value consistently.  However Risk is more quantifiable as I mentioned earlier.
Building an Efficient Frontier in the investment world is a data intensive effort, which our current product/software development processes doesn't easily support.  However I believe that we can use the formula that Markowitz created to generate an Efficient Frontier for Product and Software Development organizations.
For this effort we will make some assumptions with respect to the Frontier model and changes to Markowitz's formula so that it works with our limited data set:
  1. Portfolio = Product Development
    1. An organization can have several Products in their Portfolio -
      1. Consumer Facing
      2. Internal Facing
      3. Infrastructure
      4. Research and Development
  2. A security is equivalent to a Scrum Team.
    1. These would equate to the individual securities that Markowitz speaks to in his model.  Where an investment portfolio consists of many securities, each with their own risk/return profiles so to does an organizations product development portfolio consist of the same.  Each team is a security that can on its own provide return that comes with an associated risk.
    2. Though we don't think of investment securities as having dependencies (as software development teams have) in fact a diversified investment portfolio consists of a range of investments that will perform a certain way based upon the dependency that business has to the market that they operate in, so in this case the notion of a portfolio still holds as a viable means to build a Product Development Efficient Frontier.
  3. Potential Risk Parameters:
    1. Development Lifecycle - Waterfall, Agile, RUP, XP, Blended (use at macro level). You could equate this potentially to Bonds, Stocks or other investment instruments.
    2. Experience of Team
    3. Number of Scrum Teams
    4. % Test Automation
    5. Code Complexity
    6. Speed to Market
    7. Roadmap volatility

In my next post I'll provide some supporting ways we can 'build' an efficient frontier for Agile Product Portfolio analysis that both Product and Program Managers can utilize to assess priorities for the entire organizational backlog.

Monetizing Agile Projects

Coming from a finance background my education and experience is grounded in ensuring that money invested returns ROI.  We think of things such as ROI, IRR Cash Flow, etc... For example when a manufacturing company decides to make a hardware purchase for machinery (any kind) to produce some type of 'goods/product' they perform financial analysis regarding the cost of the equipment, the rate of return that it will generate, how quickly they can amortize it and ultimately what is the net profit that the machine is expected to generate over its anticipated lifespan.

For most of my career we start on projects that have a goal in mind, potentially new revenue or cost savings, some have gone so far as to try to determine the ROI, but in general I haven't seen the type of due diligence that manufacturing type companies perform, applied universally to software development.

This may be an underlying cause of many of the software development projects never seeing the light of day or failing to deliver the expected outcome because we never performed effective financial plans that would establish the scope and speed necessary to deliver a software product so that it warrants the investment.

In Agile I think we have ways of providing some level of financial analysis that can provide us with an understanding if an idea is worth pursuing.

  1. Using the following as a guideline we can begin to estimate costs:
    1. Team Size - 5
    2. Blended Rate - $125 an hour
    3. Hourly team rate - $625
    4. Cost of Sprint(2 weeks) - $50,000
  2. Let's assume that the feature that we want the team to work on has come back with an estimate of 5 Sprints.
    1. Estimated Development Cost - $250,000
  3. Let's now assume that this investment is expected to yield an additional $1,000,000 in annual revenue.
  4. Expected ROI in the first year - 300%

Before we engage our teams we need to be sure that the $250k investment will return an appropriate level of return.   In this simple example its a no brainer.

But our world of software development isn't always so clear-cut, we often don't know what the expected outcome will be until we release the product into the wild.  There is often additional cost for refactoring before the product hits the mark with your consumers.

But using some of these simple ways of working through anticipated costs we can easily modify the example to reflect additional Sprints for refactoring once the product is released.

In this example let's assume that the team requires an additional 8 sprints to move from MVP to final product.

The final cost of the product would climb to $625k and our return would drop significantly to 54%.  Still not bad but not the eye-popping number we initially thought it would be.

Factor in sustainment costs into this over the life of the product and you begin to see that your investments in your software absolutely need to go through the same level of analysis as other types of large infrastructure purchases that non-software organizations go through.

I'm currently working on creating a lightweight model based upon Markowitz's Efficient Frontier investment model that money managers use today to ensure that your risk and return threshold is aligned.  I'll be posting my initial thoughts and approach in a coming blog.

Agile Planning and Delivery

Agile is often viewed as the way that small organizations and teams can build product quickly and in fact I believe that to be true. Being quick and nimble allows smaller/growing organizations the ability to get into a market quickly and deliver features that larger organizations haven't delivered yet or haven't thought of.

This very ability to deliver new features to a market that desires them is the very reason that larger organizations need to change the way that they deliver their product.  As an organization becomes larger, the entropy that comes from that growth causes the organization to stop being a market leader and start being a market follower.

In the technological world we live in, you can go from market leader to out of business in just a few short years.  I read an article recently that suggests that Walmart is starting to show signs that its dominance in retail may be coming to an end.  I wouldn't be surprised, as I think they have lost sight of the fact that low prices don't always solve the things we as consumers value.  Walmart isn't a market leader anymore, they may just not have come to that realization.

It's this lag in reality when big companies start falling behind  Somewhere along the way almost every organization will lose its way, lose site of the very thing that caused them to be great in the first place.

When you look around in the Agile learning space you see many of the original creators of Agile and Scrum trying to figure out how to help large organizations get past their own entropy.  I don't think that Agile can help, it can highlight where your planning and delivery processes are inefficient but it doesn't provide the language that senior management needs to hear in order to effect real change.

If we want to help organizations transform and be 'agile' then we need to speak in the langauge of management, which is money.  I've yet to have a cogent conversation with management regarding how their lack of focus costs them money and more importantly fails to deliver the speed to market that they need in order to stay market leaders.

If you think that Agile provides you with a means to quickly change product direction in order to play defense or catchup when new features that you have been planning on are released by a competitor, then you are missing the point.  Agile does accept that change will happen, but we expect that the change will take the form of measured change in how we can make the product more valuable, not wholesale changes in direction.

Changing direction within a Sprint is something I've seen several times and it's almost always driven by management.  Whether you have too many idea's/opportunities or are just trying to stay relevant give you team time to work on one thing at a time.  Context switching reduces productivity and that you can translate into money.

The example I've been using recently is this:

If you managed your Sprints the way you manage your money you would go broke.  Take this example for consideration (note this is what good Agile teams should be forcing into the planning conversation).

Consider a team that has planned 20 points for the current sprint and someone (Product Owner, Sr. Management) has decided that something else is more important, like completing a feature for a key client.  The appropriate response from your Agile team is 'Great, let the team review the request and provide an estimate'.  Right there you have probably lost 2-3 points in analysis and estimation by the team.  Once they have completed their estimation, they come back to you and tell you that it's a 5 point effort.

You think to yourself great we can do that in this sprint,  let's do it.  A good Agile team will tell you yes we can do it but you need to remove 2-3 points for the estimation effort AND 5 points for the new work that you want us to take on in the current sprint.  So you have LOST 7-8 points of productivity, aka value) to get 5 points of value.

If you invested 8 dollars into a business and only were able to get 5 dollars back you would quickly realize that you can't sustain that monetarily, right?

Put this to your executives next time you have a priority conversation.  I didn't even bring in the  technical debt we typically take on to hack something together and the lack of testing that will happen because we weren't ready to take on the work (read no automation).

As a Finance guy I would say that this is a bad investment.  Yes I want to satisfy my customer but if they are a good customer you should be able to have an ability to manage their expectations so that the team can take on the work in the next Sprint.  Depending on when the request came in they may only have to wait 2 weeks.

Effective teams I've worked with use this process as a first line of defense against changing priorities within a Sprint.

Scaling Governance in Agile

Large organizations who move towards and Agile delivery model may struggle with how to scale any governance model.

I think if you polled most Agilists about governance in general, you would tend to get a shutter and an ugly stare.  Indeed we want to address technical excellence during our sprints but what we often fail to understand is that software engineers are not omniscient when it comes to all of the areas of technical acumen related to performance, security and other compliance type efforts.
As an organization grows and becomes more and more global it finds itself dealing with many different governing bodies that each have different requirements for how we deal with data protection, which in turn relates to how we develop our software.
Having run PCI compliance for a large organization I know first hand that providing specific information to developers with respect to what to look for just in a code review is an important first step.
Governance is needed for most organizations as a first defense when something happens with respect to security/privacy.  Organizations need processes in place to provide evidence to governing bodies, courts and legal inquires regarding how we protect our product our customers information.
Governance can include both standards and artifacts.  For example PCI compliance requires that we provide evidence of compliance with respect to their 13 security requirements.   From a software development standpoint these include such activities as code reviews that are focused on security, software development cycle, evidence of secure development and test practices in addition other efforts such as  Penetration testing and other monitoring capabilities.
In Agile we need to think of this in a light weight manner.  At one organization we implemented a set of standardized stories, non-functional, that were to be included into a teams feature development sprints.  For teams that are working on several sprint efforts before going into production this can work very well as the team is addressing this as part of the planning and estimation.  When the code is delivered to production the completed and accepted user stories (which have context as to what was completed) serve as the artifact for the PCI compliance (or other) auditors.
The engineers liked this because they were creating artifacts as they developed and from an organization standpoint we gained confidence in the fact that our code was being developed against high quality standards.
For Governance activities that relate to more ongoing product sustainment efforts the same standards need to apply however the manner in which we apply them within each sprint may be different that new product type efforts.  Automated testing and monitoring form a larger basis of maintaining the standard levels that we established in earlier cycles.
Recently I heard a statistic that said 90% of attacks can be mitigated by the basic block and tackle work that teams can do on a regular basis.
Governance doesn't have to be a bad name in the Agile space, we need to view it as part of our technical excellence efforts that form the basis of high performing Agile teams.
I think Governance is an area in Agile that is ripe for development especially at scale.

BDD - Step by Step Process Tutorial

As you might tell from some of my blog topics I'm a huge believer in BDD, not just as a means to automation but more importantly as a process that helps us define requirements more accurately. When we move into an Agile delivery model, many individuals struggle to understand how they are supposed to document everything that they used to put in their Product Requirements documents (or a whole host of other acronyms).  These documents formed the basis of our engagement with the business and with the teams that would ultimately deliver what the business thought they were asking for in the PRD.

There is an interesting game that has many flavors such as Social Telephone game, that for me, makes clear the issue with large documents that multiple groups need to review.  Each of us is individually focused on the things that we think are important and we often have different interpretations of the written word.  And as such as we work to deliver in our silos we move towards an uncommon understanding of what is being built.  I would argue that many 'defects' that are found are actually poorly interpreted requirements.

For those of you in highly regulated industries you know what I'm talking about.  The endless hours spent reading a single paragraph trying to derive the real intent and meaning behind the written word is exhausting and fraught with peril because if we get it wrong there are penalties and mad scrambles to implement a hack to make it work the 'right' way.

Software development is made hard because of these communication differences, be they cultural, language or other, they exist and they make it difficult to come to a collective understanding of what is being asked for.

User stories help break down this barrier as they define small pieces of a larger whole and place a value statement so that we understand WHY what we are being asked to build is important.  Many teams writing user stories leave off that important 'so that' statement.  Leaving off 'so that' leads to so what?

Behavior Driven Development, for me, changed the way that I looked at defining requirements because it removed the business language of things such as the business requires this, or the feature shall do that.  The statements sound powerful yet deliver little in real context for the teams to work from.

Breaking down user stories with BDD still leaves the team to work with a non-technical domain language and then provides a clear method of defining the behavior (positive and negative) for the teams to work from.

The power of context with the respective speed and quality it delivers can't be denied.  However don't be fooled that this is easy, it isn't.  Agile is extremely disciplined, something many miss on their way to the Agile party.  Done right it can take your delivery processes to new heights, done wrong it becomes just another new fangled process that doesn't work.

Below is a BDD tutorial that can get you started on your way to learning how to build contextually rich user stories.  Good luck and have fun!

BDD Training

Agile Testing

I was saddened to see that a meetup group that I managed for over two years was coming to an end because there wasn't anyone who wanted to take on the leadership role.  When I started at a Northern Virginia startup as QA Manager I was tasked with taking on the leadership role of the DC Agile Software Testers (DCAST) meetup. When I took over we had 25 people and when I left the group two years later  we had grown to a robust 450 and had developed a reputation as a place where QA professionals could meet to learn how they could be successful in an Agile environment.

I've always said that QA is the last to come around when organizations move towards Agile.  Early on in my career in Agile the QA leaders would tell me 'yeah you guys develop however you want and when you are done, then we'll test'.    The notion that QA couldn't test anything until everything was done (though in reality it never was) was strong.  The feeling of power in finding defects that were typically not defects but mis-interpretations of requirements was palpable.  The force was strong with us then. (cue the light saber sound).

With DCAST I saw quickly that the people who were coming didn't understand how they could engage in the process and more importantly they didn't understand how they could deliver 'quality' without having the entire feature delivered for testing.  Iterative testing just didn't compute.

There are many things that QA teams need to understand in order to be successful in Agile.  Some of the key elements include:

  1. Automation - For QA this needs to be a key focus of development.  Automation builds what I call 'progressive regression'.  Instead of thinking of regression as the final end to end activity, look at it as a growing entity.  With waterfall development and more manual focused testing, you get an opportunity to perform a full regression test potentially just once at the very end of the development cycle.   This leaves little time to deal with defects that arise from your testing.  With automation and continuous integration you are effectively performing a regression test of your developed features every night.
  2. Behaviour Driven Development (BDD) - The two-pronged effort to quickly develop and manage your test automation suite utilizes example based test development like BDD as your test acceptance framework.  What BDD does is ensure that the entire team is reviewing the acceptance tests that will ultimately be developed as part of the automation suite.  This process ensures highly contextual user stories that clearly define the behavior of the feature and keeps everyone focused on exactly what needs to be developed (nothing more nothing less)
  3. Parallel Teamwork - With the use of BDD, QA can develop their automation code while feature development is in flight.  If the teams are working from the same story specifications then when the code is checked in the automation should be able to run with few errors.  This is a key process to develop in order for teams to deliver quickly.  By not having parallel efforts, teams will typically fall into the cadence of having automation developed in the next sprint.  Once you go down this road you will typically see automation efforts begin to fall further behind as QA will start manually testing in order to 'stay on top of testing'.
  4. Sprint Management - QA teams need to work with their team to ensure that work is being delivered throughout the entire sprint.  A common problem teams face in Agile is that we fall into the 'mini-waterfall' process where developers deliver the features in the last day or two of the sprint.  This leaves very little time for QA to perform ad-hoc and manual break testing along with fixing any automation breaks that have occurred once the code is checked in.
  5. Zero Defect Policy - This is key.  Teams need to develop a working agreement that enforces a zero defect policy for new feature work in a Sprint.  This means that the team does not receive credit for any stories that can't be closed out with zero defects.  This focus ensures that the entire team is focused on delivering quality.
  6. Quality is EVERYONE'S responsibility - There is no such thing as 'toss it over to QA' in an Agile world.  Hey Developers, you have to help test if you deliver something late.   Don't let your software engineers tell you that they don't test.  All great developers have to be good testers ( you know TDD kind of focuses on writing tests).  The entire team is responsible for quality not just your test engineers.   Note - QA Managers this concept in no way removes the need for your existent, rather like Engineering Managers your role changes.  You should actually have time to be strategic and plan out future testing platforms and approaches for your team.

I'm glad to have led DCAST as it provided me an opportunity to help QA professionals grow their understanding of the activities and process all good Agile teams exhibit.

PMO Role in Agile - Part 2

My initial blog seemed to have some interest judging by the number of views it's received so I'm guessing that it's a topic that many are looking for input on.   So I thought I'd provide some more thoughts as to what a PMOmight  look like in an Agile organization. One of the key things that changes with a traditional Project managed organization is that they must change to one that is Product managed.  What this means is that the organization changes the way that it funds its business by essentially providing Product Owners with Scrum teams that will deliver on their vision for their product.  Given this paradigm, along with the creation of the Scrum Master role, the PMO and subsequent project managers are left outside looking in.

Managing Product driven teams means that you are managing towards outcomes that delivery value over projects that deliver features.

In my previous post I provided some suggestions as to what individual Project Managers could do to make themselves more valuable and productive to their teams.

In this post I will suggest a PMO structure that focuses on the Portfolio view and leaves the operational execution of the roadmap to the Scrum Teams and Product Owner.

For this structure to work the organization needs good Scrum Masters and preferable ones that aren't also individual contributors for their team.

The structure of the PMO will be lighter than you might think is right, but I'll argue that if you have the same number of Scrum Masters and Project Managers you will set up role confusion that will make your entire project management process cumbersome and less productive.

The PMO structure would look something like this:

PMO Org View - Agile

I think one of the things that a PMO organization needs to be aware of is that their focus is not on control of projects and people but on how teams are performing.

With this structure you have a thinner level of Project Managers who are focused on Program level Product Management (PPM new acryonym anyone?). Your Project Management function becomes one of oversight of Scrum Masters and working closely with Program Managers in other Product groups who probably will have cross org dependencies.  The Program Manager level in this structure is more about working to ensure that teams are working on the right things based upon the Product Roadmap and escalating when individual team priorities become out of line with the overal corporate product objectives.

What we want with a PMO is confidence and how we do that historically is to place controls, gateways and processes designed to show that teams are checking off boxes that we believe represent how a successful project should unfold (aka Project Governance)

How we do that in an Agile organization is to ensure that our teams we have a clear Product roadmap, that we are performing effective planning both in the areas of Product Discovery and Release Planning, that teams are provided time to review and estimate the work that they are being asked to commit to AND ensure that teams perform continual inspect and adapt cycles via Retrospectives.

If teams are allowed to form into solid high performing teams what you get from that is an organization that learns how to estimate accurately, which leads to consistent velocity which in turns leads to predictability....which is what we in the PMO (and Sr Management) are looking for, simple right?

What I learned years ago from my Project Management days is that Agile actually provides you with much more visibility and transparency about what is happening with your commitments,  providing you as the stewards of the product an ability to have fact based conversations with stakeholders who rarely understand the complexity of what they are asking for.

PMO Role in Agile

If you lead a PMO or are a PM and your organization is embarking on an Agile adoption you are probably thinking so how do I fit into this new paradigm and still manage the work that I'm currently managing (it won't manage itself is what you are thinking) ?

Organizations who are now moving towards Agile as a product delivery/SDLC method will find themselves trying to figure out where their PMO and subsequent Project Managers will fit.

The problems they face are several:
Traditional Project Managers:
  • Are experienced at managing to a specific plan and resolving resource issues that their specific projects are facing.  They are not typically assigned to just one project and the people they work with come and go with much frequency.  Project Managers have been for many years the ones who provide confidence that 'someone' has their hands on the pulse of the projects that are designed to deliver value to the organization.
  • Don't typically look at their projects as value driven, rather they are priority and resource driven.  Their focus when they are assigned to a project is about who is on my team, who can I steal from other projects and creating a plan that is often not vetted by the very people who will actually do the work and socializing that with Sr Management.
  • Traditional Project Managers are excellent deflectors of blame (yep I learned quickly how to push off issues on to someone else)
  • Are not typically contributing members of the team.
I don't say these things to make Project Managers angry, I was once a PM and a very good one at that (or so I believe).  And I'm not at all implying that there isn't a role for PM's in Agile, but I will suggest that how you think as a PM will need to change.
For starters you need to find a way to be a contributing member of the team and not just someone who sits on the sidelines like a reporter and records what is going on to report out.
The thing that was different about me was that I always managed my teams more like a Scrum Master would.  I found ways to contribute, I gained the trust of my team, I protected them and provided guidance for individuals when they were struggling with something about the organization that didn't make sense.  This process of engagement led me out of the PM role and ultimately into QA Management so there are growth opportunities for PM's if you are open to learning new things.
If the team needs help in testing, learn something new and help out.
Most Agilists' may tell you that the Scrum Master and Project Manager role are completely different.  Though they are different I would argue that project managers can fill the void of Scrum Master and gain great insight to their projects and be on point to resolve impediments more easily than be bystanders to the entire Agile process.
Here are some key areas that Project Managers should focus on during an Agile Transformation:
  1. Planning - Is not a function of setting forth an unyielding plan.  Rather planning by the team is to facilitate an ever growing understanding of what the team is building.  Big Up Front Requirements convey a static nature to projects that simply doesn't exist.  If you disagree actually track the number of times the team has to change their plans (for architecture, etc..) during a typical non-Agile project.  Teams that try to predict the future are destined to be wrong a majority of the time.  You need to become comfortable with a plan that identifies in detail only 4 weeks out.
    1. Goal - Be an active member of the team and be able to understand both the technical issues that are facing the team and bring them a clear understanding of dependencies with projects and teams that aren't in their viewfinder.
    2. GoalLearn different Agile planning techniques.  One of the key things that people miss in Agile adoption is that Planning needs to take place more often and that some level of upfront Discovery is not a bad thing.
  2. Scrum/Agile  Activities - A Project Manager for a Scrum Team needs to:
    1. Ensure that their teams are performing effective User Story development with techniques such as BDD and Specification by Example.
    2. Ensure that their teams have a well groomed set of stories in their backlog
    3. Ensure that their teams have effective Sprint Planning and Estimation sessions
    4. Ensure that the teams utilize their Retrospectives to drive continuous improvement
      1. Goal - Become an Agile evangilist, learn everything you can about Scrum, Story writing, TDD, Continuous Integration, User Story Mappiing, BDD, Specification by Example.
  3. Program Management - Is driven by the overall roadmap.  Ensuring that Scrum teams are aligning their user stories to appropriate Road Map Items keeps the organization focused on execution progress/success and provides the PMO with a clear view to all of the work that they are managing.  As an organization scales this is no small feat, so getting large sets of teams to keep up with story writing and roadmap linking is an administrative task that teams quickly tire of.  Project Managers need to provide support and assistance with the management of these types of activities in conjunction with their PO and Scrum Master.
  4. Technical Knowledge - Though this isn't as big of a problem as it was 10 years ago, many Project Managers simply don't understand the underlying technical platform that their teams are working in.  I personally don't think that you can be an effective project manager unless you have this knowledge.  Take the time to learn, your team will appreciate it and you will be able to have better fact based conversations with your Stakeholders regarding issues that delay delivery of projects.

BDD - Breaking down stories

One of the areas that many teams struggle with is getting user stories to the right level of context.  For me context IS everything in user stories.

 Yes a story is a placeholder for a conversation, but with large complex systems and organizations, the need to build out (and document) context has many benefits for teams and the organization.
Over the years I've seen some consistent elements fall out of BDD that can provide teams with an understanding of when a User Story may need to be broken down.
As you begin to build your test scenarios for your user story ensure that the story has no more than 3-4 scenarios.  If the number of scenarios is large, getting a clear contextual understanding of the story becomes much harder.  Additionally if automation is part of the equation then you end up with a larger code base for a single story and it can make trouble shooting failures harder.  Smaller stories mean less complicated acceptance criteria and more manageable and scalable automation code.
Once you have identified your test scenarios and begin writing the supporting BDD acceptance criteria look for some of these elements as queues to potentially break down your stories:
  1. Large set of parameters- If you see that you have more than 7-8 parameters in an individual test scenario consider breaking the test into additional scenario(s) or another story.  As I've taught my teams, if you see your example table stretching off the page you probably need to break it down.
  2. Large set of examples - If you see your test has more than 12-15 examples in an individual example table, you should consider breaking it down into additional scenario(s) or another story.
Keeping your stories and test examples small ensures that the team can more accurately estimate, deliver and demo their work consistently.
Teams should strive to break stories down so that they are small enough to be completed (Dev and Test) within 2-3 days.  This level of granularity provides clear visibility during Standups if the team is on track to deliver on their commitment.
Many teams suffer from what I call 'pushing a river down a creek' syndrome.  Meaning that they don't perform sufficient planning and story breakdown which leads them to continue to push their work out into future Sprints.  This leads to a lack of visibility as to when 'it will be done/delivered'
Breaking down stories effectively also leads teams to have stable velocities which leads to predictable delivery.  All of this feeds improved Program and Project management across the organization.
Organizations that need to scale Agile need to understand that this level of discipline isn't easy, but we shouldn't shy away from something just because it's hard.
BDD story breakdown leads to vastly improved feature definition, scalable automation suites and a strong automated regression.

The Agile Manager Conundrum

If your organization is moving towards Agile there are some specific elements you will need to be aware of from a Management perspective.

 Agile focuses on teams being self organizing and what that means for managers is that you need to give up some control, however that doesn't mean you are backing away completely.
Effective managers in Agile focus on these areas:
  1. Technical Vision - This is so lacking in most of the organizations.  Most organizations I've worked for have some higher level vision set in place, maybe some standards but at the execution level these tend to ignored in favor of getting 'it out the door'.  Teams incur substantial technical debt that costs real pain and money to organizations long term.  A good manager is able to set forth operational vision for the team.  Using Scrum processes such as Retrospectives, the manager can encourage the team to come up with processes that work for them that support the vision.
  2. Technical Excellence - The operational side of the vision again involves the team understanding what it takes to deliver high quality code.  Understanding how to ensure that code is refactored on a continual basis, that code reviews are not rubber stamps but should have a specific focus and structure designed to teach.  At one startup I worked for code reviews were taken very seriously and provided junior developers with an opportunity to get good feedback on how they were developing as engineers.  As a manager you need to ensure that the Alpha dog syndrome doesn't happen, good code reviews are educational not demeaning.
  3. Career Development - This is probably one of the harder areas for technical managers to be successful in because I think most organizations don't provide the right type of management training to their technical management staff.  Understanding what to look for and encourage is for me the most important element of being a good manager.  Career development provides the organization with employees who are happier, more focused, more dedicated and produce higher quality results.
No where in these areas do you see the manager handling problems with the teams project planning, etc...  Though you need to build confidence in your teams abilities to deliver, you also need to let the Scrum team and processes evolve so that they(the team) handle most of the day to day issues and keep you in reserve for the important ones that truly need management intervention.
You have plenty to do as an Agile manager, it's just not what you are probably doing today.

BDD - A team oriented activity

Probably one of the harder elements of Agile that teams struggle with is the art of collaboration. Our experiences over the years have taught us to treat functional groups such as BA's, Devs and QA as separate entities each with their own perspective and each distrustful of the others abilities to deliver.  How many times in QA do we hear the phrase 'Just toss it over to QA and let them deal with it'. 

We forget so easily that what we deliver for a customer is the sum total of our efforts, not just of individuals.  The Chicago Bulls were a good team with just Michael Jordan, but only when they were able to blend ALL of the skills of the team were they able to win championships.  Scrum is about team.
Getting your Scrum team to actually work as a team is one of the key efforts that everyone needs to make and BDD is a way that can help teams  work collaboratively to  build what I call contextually rich user stories.
You can't rely on just one or two people to write user stories and acceptance criteria as there is a limit to the context of what any one person can know.  With ever growing complexity in business and technology the more people who can collaborate the more context that is captured in the story.
Does it sound like heavy overhead?  It shouldn't.  I'm sure you have all spent hours pouring over Business or Product Development documents trying to glean enough information to build a design that will work for the next 6 months (which we know doesn't happen on any planet in this solar system).  We've always spent time trying to understand what is being asked for but in Agile we spend smaller increments of time on writing details that matter.
The most successful teams I've worked with have adopted this type of approach for building out BDD acceptance criteria:
  • Start of Sprint -
  1. During the first two days of the Sprint the QA lead and Product Owner work together to develop (and or complete) BDD acceptance criteria for the next upcoming sprint.
  2. By day three the development team should start delivering stories to QA for testing.  Additionally QA can begin their automation efforts via BDD examples with tools such as Cucumber, Fitnesse, Capybara....
  3. The engineering team needs to plan to complete all of the story development so that the last two days are open for them to  review the acceptance criteria and make changes/suggestions to the PO.  The team is also completing their designs for the upcoming sprint during the last two days and fixing any bugs that are discovered in testing.
BDD Planning Cycle v1.00
The key to this process is that before the team commits to the sprint they must all review and agree to the scope of the BDD acceptance test examples.  Without this discipline, the scope of the story and sprint will not be as precise.
As I've told my teams in the past, moving to writing BDD acceptance criteria is a mind shift in how you view both requirements and testing.  Both Development and QA can consume them for their individual efforts, but in the end, if they work against what is defined in the BDD they will both be on the same page functionally.
BDD takes the guess work out of what is being developed and that's a good thing.  For Sprints to go quickly and with high quality,  teams have to understand exactly what they are doing.  To steal from one of my favorite phrases from Bull Durham 'Don't think, it only hurts the ball club'.
BDD provides clarity for the entire team and makes demos go smoothly.
Ensuring that the team provides input, review and commitment to BDD acceptance criteria keeps everyone focused on doing just what is needed.

Behavior Driven Development is more than Automation

Recently while working with an organization going through a large Agile adoption I had the opportunity to work with a team that was open to adopting BDD acceptance criteria story development.  One of the key differences for this team was that this was the first time that they had experienced a collaborative story development effort.  Prior to this most teams in the organization looked to the Product Owner to write all of the stories, which led to stories that were not contextually rich, had little to no acceptance criteria and were difficult to demo at the end of the sprint.
As I discussed the success of the teams use of BDD I was surprised to hear feedback that indicated the organization wasn't ready for the heavy lift of using BDD and that I hadn't moved the team into BDD because their final work wasn't automated.
If that is your position then I think you are missing the point of BDD.  Yes BDD is great in that when you right acceptance criteria in the Given/When/Then format and build your example tables correctly you can obtain automation fairly easily with tools such as Cucumber, Fitnesse and a whole host of tools that have been developed to support this very successful way to build out what I call 'contextually rich' user stories.
However even if you don't automate your BDD acceptance criteria, the value you get from understanding the behavior of the features you are going to build is invaluable.
BDD came about because Dan North realized that TDD and really great code meant nothing if it didn't deliver the value or functionality that the stakeholder needed.  This concept was clearly illustrated for me at one organization I worked for when the Development Manager was lamenting about a Product his team was enhancing was pulled from the market because they didn't deliver on time in order for the organization to stay competitive in the market.  He said 'If only they could see all of the cool code that we've written'....To which I said 'Business doesn't care about code they care about delivery" no matter how great your product is from a code perspective it matters not at all if you don't deliver it when your customer needs it.
For those of you who are exploring the use of BDD with your Scrum teams understand that there are essentially two separate efforts that effective teams are working on:
1. Team collaboration - Successful teams using BDD understand that they all need to be involved when building out user story context with Given/When/Then.  In fact I would argue that this is the most important element that drives a clear understanding of what we are building and guidance to when a user story is done.
2. Automation - One of key components of successful Agile teams is the development and maintenance of an effective automation suite.  Utilizing BDD provides an effective way for teams to obtain high levels of automation and do so within the Sprint that they are working in.  A common mistake of newer Agile teams is to develop in one sprint and test in the next and sometimes automate in the third.  Using BDD automation tools such as Cucumber with well written acceptance criteria (I'll provide examples of well written BDD in my next blog post)
A third benefit of BDD is that a Scrum Team builds a clear understanding of the scope of the story.  Since everyone participates in the development of the acceptance criteria, if a scenario is missed, it's a shared miss - No finger pointing, just manage the new scope with a new story and prioritize it in the backlog.
I've helped a number of organizations implement BDD effectively,  one of which did not have any automation at all.  The use of BDD acceptance criteria writing almost immediately improved the understanding of the features being developed and helped my QA team write significantly more test cases than they had been doing.  This effort led to a measurable improvement in Quality even before we added the automation suite later.
Having come from a waterfall world many years ago I can tell you that when you 'get' BDD,  it changes the way that you look at requirements and provides you with a mental framework that you can quickly use to model what is going to be built.
After a few months of using this format at Disney the Product Owners were uniform in their agreement that there simply was no other way that they would want to work with their teams.
Automation IS our goal, but it is not what defines BDD.

Being Agile - Say it, Do it, Prove it

I was working with a team recently and as we talked about all of the planning that Agile entails, I broke it down into very simple terms - Say it , Do it , Prove it. That is really what Agile is about.  Anything else outside of these three concepts is noise to your ability to deliver product and services to internal and external customers.  As Product Owners in an Agile organization, you need to understand all of the effort and dynamics involved in getting your teams to Say it, Do it, Prove it.

Delivering what you say you are going to deliver is the best way to build credibility with your stakeholders.

For Agile teams, this translates into being effective at decomposing your stories into small enough increments so that you are confident in your understanding of the user story and estimates that the team believes in.

  1. Say it = Release Planning and Backlog Grooming -
    1. Starting at a high level, the Product Owner is responsible for saying what is important to the organization from a value standpoint and beginning the process of developing a user story backlog that supports this vision.
    2. User story decomposition is so important to effective Agile teams and the Product Owner must start with a set of well-formed stories that provide context to the team.
    3. What is 'context'?   Context is anything that provides definition.  It is basically what the product should do from a functional standpoint.  One of the biggest mistakes many teams make is writing declarative stories that start with the 'How'.  This,\ in turn,  puts the technical team on the defensive as they may have many different ways to implement the feature.  As a Product Owner, be sure to steer clear of writing stories that define how you think the feature story should be implemented.  I know that as we all become well versed in technology there is a strong desire to show off our technical chops, however, as a PO you need to provide context from a business standpoint that your tech teams can consume. I've heard time and again from engineers that they would really like to understand how what they are developing delivers business value or solves a particular pain point for the customer.  The team works much more effectively when they are completely grounded in the business context of what they are building.
  2. Do it = Sprint execution 
    1. An important element for teams to address once they are ready to take stories into a sprint, is that the goal during the Release Planning and Backlog Grooming activities was to begin to build out the context of 'How' the story will be implemented.  It is so important for teams to understand that there is essentially a handoff from the PO to the Scrum Team and that each of them is responsible for building what I call contextually rich user stories.  Gojko Adzic calls this Specifications by Example.  Effective teams who deliver fast and with high quality work closely as a team.
    2.  I believe that the combination of User driven stories and context driven specifications (examples) forms an extremely strong definition of both Ready and Done. which is why I coach my teams to utilize BDD as the basis for developing their User Story acceptance criteria.  The team works together to complete BDD acceptance criteria forming a clear understanding of the boundaries of the feature.  This provides the PO with a concise view of what to expect during the Demo.
    3. Another key benefit of writing BDD as part of your user story writing is that the test automation engineers can easily consume this as part of their code development for the automation.  PO's should push to get to this level of context as it also means that your test engineers can start developing their test automation code once the story is ready for development.  They can essentially perform TDD in that they can write their automation before the feature is actually developed.  Once developed the automation should run cleanly and both speed and quality are attained.
    4. The goal of teams should be to deliver user stories that do not require much further elaboration once the sprint begins.  You want your teams focused on delivery ,not on discovery.
  3. Prove it = Retrospective
    1. You have done all of the work to clearly define your user stories with high levels of context.  With all of this effort, the Retrospective should be an easy affair to show the work that was defined in the stories.  The PO should not have any surprises.  In fact, if the team misses any test scenarios after the story has been started, the PO should consider that more of a missed requirement over anything else.  Since the entire team developed the stories,  there can be no finger-pointing at anyone.  It was a shared miss and everyone must accept it.

It sounds really simple when broken down into these 3 basics phrases.  The truth is that 'Being Agile' is much more involved than simply 'Doing Agile'.

"Being Agile" means exposing all of the inefficiencies in your product development processes.  It requires that the organization be completely honest in assessing what is not working and committing to letting the teams that do the work fix these processes.  You cannot top down drive the type of organizational change that is required for Agile continuous improvement.  Real organizational change is fostered at the top but truly owned by the Scrum teams that form in support of any Agile adoption.

Building great products

A long time ago I left college with the notion that I wanted to ultimately run my own business, my job experiences were purposefully diverse, giving me experience in Sales, Banking, Management and ultimately IT and luckily I've been able to do that several times. While I wasn't always engaged in the world of technology during some of its growth, I've always been involved in building and delivering great product.

What I learned during this time is that building great products is much like writing a symphony, you have many instruments that you can choose from for your piece, but if you don't bring them together in the right way, if you don't understand the limitations of those instruments you don't end up with a masterpiece, but rather something that might sound like noise.

I have often used the concept of a symphony as an example for the way that we manage software project delivery.  You have an individual, Conductor, who is responsible for ensuring that everyone in the symphony is playing their parts correctly, are watching the conductor for queues on changes that might be made in the middle of the concert.  When everything comes together correctly you get beautiful music, when it doesn't.....not so nice.  Building software in an Agile world is much like this, the Conductor is the Product Owner and the delivery teams are the musicians who watch the conductor for their queues when small changes are made in the delivery.

Understanding your craft, be it song writing, engineering, sales, etc....is an important element of you becoming great at what you do.  The craft of building great products is being able to master how to manage all of these different crafts in order to bring about something great.  My wife, who is an Arts Manager, has often likened software development as just as much as artists realm as an engineering one.  I have another post I'm writing that explores this in more depth.

For those of us who build a product with software we define our vision, much like a composer will do.  Once the vision is identified then we determine what components (or instruments) we will need to accomplish our vision.

What are the types of instruments that we use build product with software?

  1. Product Owners/Managers
  2. Product Developers
  3. Product Testers
  4. Software - Java, .Net, etc...
  5. Hardware - Servers, Databases, etc..

What is our endgame with these ingredients?  Build product with software that delivers functionality that customers want and are willing to pay for.  If our instruments aren't aligned with this primary goal, we'll waste time and money and deliver quality that isn't what the customer expected.

When we talk about quality in the software world, we talk about defects, code quality, etc..., however from a holistic standpoint none of this matters if you haven't delivered a product that people want.  Your first goal as a Product Development team is to understand and align yourself to this completely.  If you focus more on delivering technical quality then you aren't delivering the quality that the customer is expecting. Using the example of a restaurant, I can cook and deliver the absolutely best Pasta Primavera to you, but if in fact you wanted a Steak, then I have missed your quality expectations.  It doesn't matter how good the food was, how well it was delivered, it failed to meet your expectations so the entire element of how you perceive the quality of my business is affected.

I think we are moving towards understanding this with concepts such as Personas, however I'll be honest I've been in only one place  where we paid attention to these personas as we built our product,  I think many of our high-tech companies that have evolved over the past 10 years are much more focused on the technical aspects of the product over what the customer wants.  Example?  Facebook, Google.  They release new features and then gauge response and then remove or modify the product features based upon feedback.   I think long-term this is not the paradigm that will bring success to most organizations, eventually you need to be driving your company based upon what your customers want, not what seems cool and technically challenging.

Building great product has absolutely nothing to do with technology.  Technology is merely the enabler of a product that customers want and are willing to pay for.   If we could find a different way to deliver the product without technology (or at least the technology we have in place today) we would do that in a heartbeat.

If we are to re-align our instruments as a technology team delivering quality what would they look like?

  1. A clear understanding of what the customer wants, ensuring that whatever we work on is aligned to that need.
  2. A clear set of requirements that support that need.  Agile provides a process for capturing user needs with User Stories, however the key miss I see with most user stories is that they aren't written to align to the customer need.
  3. A set of software specifications that support the User driven stories.
    1.  What do we mean specifications? Using tools and processes such as TDD and BDD to define the user story at the technical level.  Again another big miss I see with teams who write user stories is their acceptance criteria stays too high level to understand the technical elements we need to delivery as part of our technical quality.
    2. Though Agile is about conversations over documentation, we really can't deliver high quality software unless we build a shared understanding of the user stories and a depth of understanding via specifications.
  4. A feedback loop that delivers customer feedback to everything we do.

Notice, in the new set of instruments there is no mention of technology, how you deliver a feature is entirely up to the technologists.  Their responsibility is to deliver customer features, the expectation as professionals is that they will do it with quality.

Delivering great products comes from the intersection of  customer needs and high quality technology.  Great product can survive from lack of technical quality in the short team but it can never survive the lack of focus on features driven by the customer.

Agile Certifications - Why they aren't neccessary

Agile started many years ago with some basic (note I do not say simple) concepts related to how we should work together to build better software products.  Though I struggle with the notion that mere communication among individuals can deliver quality software, it can provide a product that is closer in alignment with the product owner's vision. I remember as Agile unfolded there was a debate on whether we needed things such as certifications.  I recall the argument that the very process of creating certifications for things such as Scrum would defeat the very benefits that the Agile manifesto was attempting to address.

Now many years into the manifesto I have to say that these certifications have brought an element of rigor that 'can' be beneficial but I think often stifle the creativity that can come out of Agile teamwork.  Certifications do not make you a great Scrum Master nor a Product Owner, they merely convey that you have taken a 1-2 day class that has provided you with the  evolved standards that Scrum has been defined to be.

I've been involved in a number of Agile transformations along with working in already high performing agile organizations and none of them are alike.  One thing I have taken  away is that teams who are provided space to try new things often find creative ways to solve the unique challenges they face.

As someone who started in Agile from the project management perspective I quickly realized that I was not your standard project manager who managed against a project plan, happily disconnected from my team.  No I was always learning, asking questions, it is how I went from a project manager into QA, because I took an active role in being in helping my team deliver great software.  Through out it all I was most focused on getting feedback from my team in order to improve our processes.

In those early days there were no certifications, we just took the concepts and did what worked and continued to evaluate how and what we did.  With certifications there is almost a cookie cutter approach to engaging Agile that I don't believe was the intent of the original writers of the manifesto.

Scrum and the processes it provides are extremely important, I'm not saying that these don't bring value.  What I am saying is that you don't need certifications in order to be good at Agile and Scrum.

I always tell my teams, Agile isn't easy, it will highlight every weakness in your delivery process and force you to ask hard questions about how much the organization is committed to changing the way they deliver a product.  Having a Scrum Master or Product Owner certification does not help in these situations.  What does help is working with an experienced Agile coach who has been in the trenches, who is experienced in the demands that Agile and the transformation present.

As an organization looking to adopt Agile, getting certifications for your team is not a requirement to working the concepts that so many teams use to be successful in Agile.  Don't let certifying your team be a precursor to moving toward Agile.  At one organization I worked at we took this approach and ultimately it wasn't necessary as the majority of the people who were 'certified' were not involved in working in daily Scrum team activities.

An experienced coach will be able to guide you through how to work as a team, manage communication and change the way that you deliver software products and your organization.

And yes I have several certifications including CPO and CSM and know that these are now almost standard requirements for anyone wanting to work in an Agile environment However if you are just starting Agile don't assume that someone who has been certified is necessarily an experienced practioner.  When looking for help in adopting Agile you should look for someone who has been involved in more than 5 different Agile implementations or organizations, perspective is worth it's weight in gold.

Product Discovery - Uncover your backlog in Agile

Much of the writing and learning that you gain about Agile focuses on the day to day nuts and bolts part of execution, however I think that teams are missing a much greater opportunity to improve the quality of both execution and delivery if they spent more time developing their backlog. My teams consistently hear me talk about getting contextually rich user stories  as part being able to delivery quickly and with high quality.

In order to get to the point that we have contextually rich user stories teams need to spend some dedicated time building out their product backlog.

Whether you are developing an entirely new product or simply adding features to your existing product, taking the time to fully investigate and build out your User Story backlog is important.

Much is said about doing just enough documentation to get the job done, but what I've seen over the years is that teams that fail to build out user stories that have a specific set of information in them will spend more time trying to figure out what they are doing IN the sprint which negatively impacts quality and the teams velocity.

There is nothing wrong with spending time before a set of sprints building a strong understanding of what the team is going to do.

You wouldn't try to build a house without a certain level of planning ahead of time.  Agile teams often arrive at the start of their Sprints with nothing more than a set of ideas.  If builders showed up at a job site to start building your home with only a rough idea of what you wanted, they couldn't go very quickly nor would they build something of quality that met your needs and expectations.  You might get what you want, but probably not.

Agile teams need to take this approach a bit more, spending time with their Product Managers to not just flush out the features that are wanted, but more importantly the lower level details needed to provide the team an ability to plan more effectively and deliver high quality products.

If a builder shows  up and wanted to pour a basement, they need to know more than that.  They need to know the size of the basement (ie how much concrete do I need) , if the site has been prepared, has drainage been considered, etc.... Building anything of quality requires planning before you can deliver.

Agile I think too often believes that you can go lite on the planning and still delivery quality.  If you think that refactoring is the golden ticket for lack of planning, it's not.  Rarely do teams have time to do the amount of refactoring they require to keep their applications clean and scalable.  This leads to applications that grow in complexity requiring even more time to add features, all the while thinking that we can go lite on planning.

As you consider Agile as a development process, don't forget that Product Discovery is an important element of delivering high quality product quickly.

Agile, Change and the things we can do

We home school our children and a few years ago my wife decided to utilize stories and a Kanban board to manage the kids work flow every day. Doing this provided her the ability to build a backlog of work tasks that our children were going to work on (no we didn't have them perform estimations or commitments :) )  Each day she puts up the work that they need to complete in the Not Started column and then the kids can decide which ones that they want to work on and pull the ticket into the In Progress column.

Once they are done with a ticket my wife reviews the work and if accepted moves the ticket to Accepted.  This approach provided our kids with some level of control over their work flow and also an understanding that they weren't done until Mom signed off on their work.  This way of managing their work provide them visibility to how much is left for the day and more importantly the topics that cause them more trouble.

Now that my daughter is working on her first business/website (she's 13) we are using an Agile Discovery process where we are building a User Story backlog (she's learning VOC) and developing low-fi wireframes (she's learning design) for her website where she will be selling her customized jewelry made out of recycled products, photography of the animals she has seen across the country and raising awareness of animal conservation.  She's now comfortable with an Agile process because we laid the groundwork during school.  I think in many ways teachers could utilize this process which would provide visibility to high performing individuals and those that are struggling.  Taking a page from Scrum perhaps the high performing individuals can provide support to the ones that may be struggling, just like we would expect our Scrum teams to do when someone is struggling with a particularly gnarly code problem.

Agile is most commonly associated with Software Development, but really the iterative continuous improvement concepts apply to anything you want to focus on.

Agile can be applied to changing your habits.  For example if you want to lose weight, write an Epic stating that value of losing weight, then write several thematic user stories with your intermediate goals and then write stories for your sprints with specific activities you need to accomplish (exercise, etc...) put it on the wall for your Kanban tracking.  If necessary have a standup with people who are supporting you so you can report on your progress, impediments (Ben and Jerry's is right next to my office...)

An underlying principle of Agile is the need to change behavior, not just of the teams building your product but those that want them built.  You can't have a smooth running organization if you don't address the intrinsic  behavior of people in general.  Agile can provide the framework for helping make this change by providing a shared language.

When we work in an organization we may think we are all working towards an end goal (ie making great products, making money, etc...) but as soon as an organization begins to grow people who don't know each other and who may have no shared experiences need to start communicating.

I recently completed McCarthy's Core Protocol training  and one of the things I came away from it was that getting people to have a shared framework of communication is the most important thing that high performing teams and organizations should focus on, the rest will come as a result of this effort.  If you deliver this you deliver the ability for these teams to produce great product anywhere/anytime.

Think about it this way - We are all organic systems, who behave based upon the experiences that we take in over our life time.  Since no two humans are organically the same ( not even your own family) we end up with an ineffective communication driven by our life experiences and trained responses.

Core Protocols and in my mind Agile, provide a framework to establish a common language, just as we do with disparate technical systems (isn't that what a service based architecture is all about?), we write code that provides a common communication protocol between them, removing the impediment their different languages pose to having them communication effectively.

As you begin to start to adopt Agile understand that though the practices you read about, such a Release Planning, etc... are extremely important, the need to provide your teams and organizations a shared communication framework are equally important to long-term success.

Sound Agile - Aligning Agile with Soundness

As I indicated in my last post I renamed my blog to Sound Agile and I'll be writing about Agile from the perspective of Soundness and how organizations should be evaluating their Agile adoption. I spent quite a bit of time trying to decide what I wanted to name my consulting business and blog (both are called Sound Agile) and I ultimately wanted to convey what I have seen as successful with respect to the teams and organizations I have worked with over the past 10 years.

Thanks to my wife for providing me a word that when I looked at it provided me with the right context to what I had been trying to convey.

Sound: 

adjective

1. free from injury, damage, defect, disease, etc.; in good condition; healthy; robust: a sound heart; a sound mind.

Supporting Manifesto - Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

a. Free from Defect - Speaks to Quality that we strive for in Agile. b. Healthy - Speaks to your employees health and well-being c. Robust - Speaks to building scalable products. d. Sound Mind - Speaks to teams keeping a clear and open mind to improve

2. financially strong, secure, or reliable: a sound business; sound investments.

Supporting Manifesto - Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

a. Sound business/investment - Speaks to the value proposition that Agile focuses on. b. Financially strong, secure and reliable - Speaks to the ability of Agile teams to delivery products that are foundational to your organizations long term health and security.

3. Competent, sensible, or valid: sound judgment - This speaks to trusting that the people that you are hire are compentent and when following Agile ceremonies such as Standups, Retrospectives and Planning are able to deliver product that is built on solid decisions.

4. Having no defect as to truth, justice, wisdom, or reason: sound advice. - This speaks to the continuous improvement and Retrospectives that drive this effort.

5. Of substantial or enduring character: sound moral values - Speaks to team commitments, believing and supporting themselves, the foundation of Scrum.

We spend so much time writing and talking about things that we should, could, might do to deliver Agile,  We hear people talk about how 'Agile' are you, tell people that doesn't 'Sound Agile' and I think we have muddied the waters of what Agile should be.

When you hear Sound Agile you may be inclined to add an additional adjective 'Sounds Like Agile' and to some degree that is expected.  My focus however will be on the soundness of Agile from the perspective of organizational change an area that isn't really talked about as much as the other elements of day to day Scrum.

I look forward to comments and input to my blog as my writings will form the basis for the types of coaching and consulting I hope to do in the future.

New Blog Name - Sound Agile

As you may have noticed I updated the name on my blog to better reflect where I am going with content and my overall beliefs about what sound Agile practices should be. Sound Agile is derived from the attributes of sound:

sound

1. free from injury, damage, defect, disease, etc.; in good condition; healthy; robust: a sound heart; a sound mind.

2. financially strong, secure, or reliable: a sound business; sound investments.

3. competent, sensible, or valid: sound judgment.

4. having no defect as to truth, justice, wisdom, or reason: sound advice.

5. of substantial or enduring character: sound moral values.

I'll be overlaying my writing on top of Sound to reflect the need I believe to focus on sound judgement over growing process.

You will see my website www.soundagile.com take shape in the next few weeks, please check it out.

Contextually Rich User Stories - The Importance of Details in Small Increments

Every software product that we build begins with a set of requirements. Teams or organizations who have utilized traditional requirements documentation efforts such as Product or Business requirements documents (PRD's or BRD's) typically have issues with translating their requirements process into user stories.  Instead of writing long passages of descriptive requirements that are heavy on the use of 'the user shall' we move to a smaller specification document that convey details to a specific individual feature.

What teams fail to realize is that their old requirements documents weren't all that good at conveying the necessary details that allow teams to delivery their product quickly and with quality.  You see evidence of this lack of clarity with the large number of change requests that are raised during waterfall projects.  In my pre-Agile years it was not uncommon for a typical 6 month project that I led to have over 100 change requests generated to convey the changing nature of the requirements (business, technical and UX).  The Agile manifesto addresses this reality by saying we accept change, why?  Because it's there it will happen, to deny it would be to deny the reality of product development, as we learn more we need to change our approach.

User stories, though small in format, need to have a specific level of detail if a team is to have the ability to accurately estimate and delivery the feature.

The basic User Story:

  • Story
  • Conversation
  • Acceptance Criteria

Can be deceptively simple to those who are just starting

In one organization I worked with as we moved into an Agile process the team looked at the User Story statement  as THE requirement.  It took awhile to get them to learn that successful teams use the User Story format as a specification and not a loose statement with no context associated with it.

An example of a solid User Story specification would look like this:

Story Format

Another important thing to note with this format is that the team is also collaboratively building Story acceptance criteria by using Behavior Driven Development (BDD) which directly feeds the test automation frameworks that most Agile teams utilize (Cucumber, Fitnesse, to name a few).

There are other efforts/processes that feed into getting the right amount of detail into the story such as Discovery and Pre-Planning and if these are missed you will not obtain the benefits of this format.

Over the past 5 years, teams I have engaged with, who have used this specific format for developing their User Stories have had a much greater success with both delivering on time and more importantly with higher quality.

At my last organization I asked a Scrum team to utilize this process during the Pre-Planning phase of their project.  After the project I learned that the Product Owner had been very worried about the team using precious 'development' time to talk through the work and build out the context of the user stories. After the project was completed he could state without reservation that taking the time to build out contextually rich user stories with the team had produced two key results:

  1. The team delivered on time and with more features than he had originally promised the client.
  2. When he delivered the demo to the client he had high confidence in the product as it met all of the context that had been build out and there were only 2 minor UI issues that were identified during the 3 iteration project.

Take away - Don't run before you are ready and get the context right before developing.

Member Login
Welcome, (First Name)!

Forgot? Show
Log In
Enter Member Area
My Profile Not a member? Sign up. Log Out