10x Agile Iterations

Incorporating agile iterations in your development to improve business outcomes

Software Development is a Messy Business

How often do we hear in our work week there surprises like “There is a change in priority, “We need to do this now ahead of that ”, “There is a change of plan in the product direction”, “There is a new feature request from customer”, “There is a competitive pressure for this new feature” and most recently on a higher frequency “Sam has decided to leave the company”. Yes, we all hear about these when we have a solid road map created and the team focused on delivering that road map. All these threaten to derail our best-laid plans. The problem feels even more challenging if you’re following the waterfall model for software development where plans and commitments are all but locked and loaded.

Most recently I was involved in leading a market-first enterprise project designed from scratch where we had to go over everything from prioritization changes, scope changes, team changes, late engineering discoveries, design optimization, scale challenges, product direction changes, and competitive changes. We started the project with a couple of senior engineers and summer interns working on proofs of concept modules and demonstrated the feasibility of the product to the leadership team and engineering colleagues. We got the funding and go-ahead to execute on the product. Being a 1.0 product release, we anticipated the risk of design/product issues and came up with a bi-weekly milestone-based execution plan. At the very first milestone, we hit a roadblock with respect to Zookeeper’s due to the amount of inventory from multiple sites, ZK was not able to handle the inventory updates. At this juncture of the project, we re-calibrated the milestones to include these new critical design choices to use an external cloud-based inventory store. Since this was a scale issue, we were able to move a few cluster inventory to the cloud in the immediate milestone to demonstrate the success of the design and instill confidence within and outside of the team. We tackled a few more issues along our way in the same manner of small, achievable, and flexible milestones.

There were many more surprises, of course, but the elasticity of the milestones allowed us to keep the agility for the project and also allowed us to add more features and functionalities to the future milestones. We were also delivering critical fixes and patches to existing product releases while keeping the new project in motion while continuously hitting the milestones. 

We were able to keep the team motivated and keep up the high morale due to the frequent milestone deliverables and progress shown in the demos. Engineers were happy since they saw continuous demonstrable progress and frequent feedback available during the milestone demo. 

Agile Iterations Model

• Agile development is when teams gradually build up the features and functions but don’t wait until each of these is complete before releasing. They release a basic version of each feature and add to that feature in subsequent iterative releases, usually based on feedback from the basic version released.

• The whole idea is to deliver a “working” version of a feature (however minimal) to the users so we can get feedback early in the process. Compare that with having to build a fully functional feature for a few months, only to find out that what has been built doesn’t meet the users’ needs. 

• The key development principle here is rapidly deliver working parts of the feature without keeping any of the dependent modules on the back burner. Also have the external partners within (UI/Mocks, QA test plan, CI/CD pipeline, Automation plan) and outside of the organization (3rd party vendor dependencies like Cloud provider integration, certification/qualification) part of the working version of the feature. These need not be demo-able or user-visible but make sure progress is achieved in each of the building blocks of the product. 

• This is not limited to developmental engineering as I mentioned earlier, the entire dependency model needs to move forward. More often engineering projects miss out on external dependencies which are difficult at a later stage to add. In a rapid iterative model, everything needs to be iterative and quick.

Milestones Powered by Product/Feature Demos

• Initial slicing the design and development can focus on splitting the project deliverables into multiple milestones. Consider these milestones as checkpoints for a working version to ensure the entire project is moving along towards the end product. The first milestone could be as simple as Design/Functional Specs or Sprint based in the case of Agile projects. 

• The next milestone could be a stripped-back version of all the required functionality, when we say all, yes all functionality should move forward.

• Let's say a simple Shopping cart implementation should have namely search, product information, a shopping basket, checkout, favorites, and customer reviews. The milestone should demonstrate each of these functional areas. For the second iterative milestone, the team would improve some of the existing basic functionality, taking into account feedback from stakeholders or customers, or other inputs such as analytics. On every subsequent iterative milestone, new ideas and requirements refinements if possible are added or low value/usage areas may be removed.

• Learning comes from both the development and use of the system, where possible key steps in the process start with a simple implementation of a subset of the software requirements and iteratively enhance the evolving versions until the full system is implemented.

• At each milestone iteration, the design could be re-evaluated and modifications are made and new functional capabilities are added learning comes from both the development and use of the system, where possible key steps in the process start with a simple implementation of a subset of the software requirements and iteratively enhance the evolving versions until the full system is implemented.

• Each milestone should have been tested well and if possible provide early access to QA automation tests so that regressions are avoided. Quality and performance benchmarks should be evaluated at each stage of the milestone and strive for betterment.

Benefits of Incremental/Iterative Approach

• The complementary characteristics of agile iterations can make the development and release process informative and more effective. 

• Limited ‘Beta’ iterative releases are a way to get early feedback from the users before a full increment is released to all users. 

• It’s a good way of de-risking a release and getting early and frequent feedback from the users.

• Keep the team motivation high by frequent feedback, feature development visibility, pride of ownership, and sense of purpose.

• Instill confidence with cross-functional teams like sales and marketing. Seeing is believing.

• The right approach for your organization does depend on the market, the culture of the organization, the phase of growth of the organization is in i.e. Is the company profitable? What is the size of the organization? The number of users? The impact on reputation in case of a feature-poor or basic release?

• Develop/guide the team to make decisions with the available/limited set of information or clarity of the product/feature usage. Demonstrating the feature workflow during the demo to the stakeholders allows everyone to get in together to bring more clarity and predictability.

Watch out for these Pitfalls

• Quality is everything. Keep a tight lid on quality by making it a habit for you and the team. 

• Do not cut corners for the sake of achieving the milestone. 

• For every milestone, look at how the customer is going to use these milestone deliverables, if it's partial, make sure the next iteration completes the feature

• Each milestone deliverable should be fully coded and tested, and the common expectation is that the work of an iteration will not need to be revisited.

• Reduce repetition and focus on reusable components.

• Reduce throw-away work.

• Make sure we do a good job early in identifying all the internal and external  dependencies and include them in the milestone. Never let any dependency miss out on improvement or moving forward in a milestone.

Jaidil Karippara, Guest @ 10xManager