What Is A Major Benefit Of Reducing Batch Size?

How to reduce batch size in Active software development

By Nathan Donaldson

22 November 2018

Tags: Active , Development

Reducing batch size is a secret weapon in Agile software development. In this post we await at what batch size is, how small batches reduce risks, and what practical steps we can take to reduce batch size.

We must develop software quicker than customers tin can alter their mind nigh what they want.
Mary Poppendiek

As we saw in our before posts, the iv key adventure direction tools for Agile software development — prioritisation, transparency, batch size and work in progress — each reduce 1 or more of the most common risks: risks to quality, time, cost and value.

Get your consummate guide to
Project hazard management with Agile

When nosotros reduce batch size we get our products to marketplace faster and get to observe quality issues early and often. As a result, we reduce the gamble that nosotros'll go over fourth dimension and budget or that we'll fail to deliver the quality our customers demand.

Batch size is the corporeality of work we transport betwixt stages in our workflow. Importantly, we can only consider a batch complete when information technology has progressed the full length of our workflow, and it is delivering value. Take building a new mobile application as an example. If we started by completing all of the analysis before handing off to another squad or team member to begin developing the application we would accept a larger batch size than if we completed the analysis on one feature before handing information technology off to be developed. And the batch volition only be complete when customers are able to utilise and relish the application.

What is the trouble?

The needs of the market change so quickly that if nosotros take years to develop and deliver solutions to market place we gamble delivering a solution to a market that has moved on. The software industry has been plagued by late discovery of quality and needs.

Projects may be many months or even years in progress earlier a single line of lawmaking is tested. It is not until this late phase that the quality of the code, and the thinking that inspired the lawmaking, becomes visible. Historically this has happened besides tardily. We have over-invested in discovery and analysis without being able to measure out quality. This leads to project overruns in time and money and to delivering out-of-date solutions.

What is batch size?

Batch size is the amount of work we exercise before releasing or integrating. Ofttimes projects piece of work with a number of different batch sizes. There may be a batch size for each stage (funding, specification, architecture, design, evolution etc), a batch size for release to testing and a batch size for release to the client (internal or external).

In the context of an Active software development project we see batch size at unlike scales. There is the user story or utilise example, which is the unit of work for the team. Stories inherently accept a limited batch size as they are sized so they can be delivered in a single iteration. Stories may be the elective parts of larger features, themes or epics. In a scaled Agile environment we may also see portfolio epics also as a batch. If the Agile team is a Scrum team we also have the Sprint as a batch of work. Again, small batch size is built in because nosotros aim for short Sprints and but bring in the stories we guess nosotros tin complete in that Sprint.

For individuals working on a team, they may take their work batch (story or use instance) and suspension it downwards further by continuously integrating their work, every few minutes or hours.

Then there is the release, which is the unit of measurement of work for the business concern.

Why is information technology important to reduce batch size?

In The Principles of Product Development Flow, his seminal work on second generation Lean product development, Don Reinertsen describes batch size equally one of the product developer'southward most of import tools.

Reinertsen points out that information technology tin can experience counterintuitive to reduce batch size because large batches seem to offer economies of scale. Analysing the economic science of batch size, nevertheless, reveals that these economies are significantly outweighed by the benefits of reducing batch size.

As batch size increases then does the effort involved and the fourth dimension taken to complete the batch. This causes a number of primal issues. One, transparency is reduced, which can lead to tardily discovery of issues, of price and of value. Two, integration endeavour is increased. The corporeality of time and try needed to integrate the new batch into the existing code base rises as the size of the batch increases. Three, value is delayed. Fourth and lastly, variability increases.

Let'south await at each of these bug in more particular.

Increased batch size reduces transparency

There are two main reasons larger batches reduce transparency.

Considering they take longer to complete, large batches delay the identification of risks to quality. With a twelvemonth-long batch, nosotros merely discover the quality of our work at the finish of that year. In week-long batches, nosotros discover the quality every calendar week. This means we get to influence that quality every week rather than having to deal with historical quality issues.  Because security is a central quality factor, reducing batch size is an important manner to manage security risks in Active software projects.

Moreover, large batches tend to have more than moving parts. The interrelations between these dissimilar parts make the organization more complex, harder to understand and less transparent.

These two issues feed into each other. It'southward harder to identify the causes of historical quality issues with a big batch project because it's hard to disentangle the multiple moving parts.

As a result you besides lose transparency of capacity. It'due south not until you have released the batch, and remediated the historical quality problems, that you tin quantify how much piece of work you have the capacity to complete over a set period.

It's common for big batch projects to go too big to fail. Equally a result the business decides to add whatsoever resource is needed to go the project over the line. Teams are oft pressured to piece of work longer hours not charged to the project. This may complete the project but disguises the bodily resource required. It also results in burnout and consequent staff retention issues.

Integration effort rises as batch size increases

The complexity created by multiple moving parts ways it takes more attempt to integrate large batches. The bigger the batch, the more than component parts, and the more than relationships betwixt component parts.

Take debugging for example. Each line of code you add together increases the number of relationships exponentially, making information technology exponentially harder to place and fix the cause or causes of a bug.

Nosotros run across similar increases in endeavour when we come to deploy and release.

The delivery of value is delayed by larger batch sizes

Larger batches take longer to consummate, and therefore longer to evangelize value. Value delayed is a cost to the business concern.

This filibuster affects both the learning benefits you get from, for instance, beta testing an increment of potentially shippable software, and the value you provide your users when you deploy software.

Compounding this delay is the increased likelihood of slippage, as cost and completion targets get pushed out. Reinertsen reports that big batches increment slippage exponentially. He says 1 system told him their slippage increased past the fourth power — they constitute that when they doubled the project duration information technology caused xvi times the slippage.

We've constitute that past tightly prioritising the functionality of our products we've been able to reduce batch size and speed upwards the delivery of value. Learn more in our case study on reducing take chances with Agile prioritisation on the IntuitionHQ project.

Larger batch sizes lead to increased variability

As large batches move through our workflows they cause periodic overloads. Reinertsen compares it to a restaurant. If 100 customers arrive at the aforementioned time then the waiting staff and kitchen won't be able to cope, resulting in large queues, long waits and disgruntled customers. If, on the other hand, the patrons arrive in smaller groups, there will be sufficient resource available to complete each club in practiced fourth dimension.

The same applies to software evolution. If you've worked on a new version of an application for a yr before you test information technology, your testing squad will be overloaded and will crusade delays.

Batch size evaluation

Fill in the table below to see how your projection or organisation is doing with batch size.

Download your printable batch size evaluation checklist (PDF)

Exercise	Yes/No
Batch size is monitored at all stages (east.yard. funding, planning, discovery, prototyping, defining requirements, development, testing, integration, deployment)
Batch size is controlled at all stages
Teams break work downwards into the smallest sensible batch sizes
Teams deliver work in increments of potentially shippable software
Teams complete work in vertical slices
Test Driven Development is employed
Teams integrate early and often
Teams deploy frequently
Communication is in minor batches, ideally face-to-face and in good time

Add up 1 signal for every question to which you answered 'yep'.

0-two points: Batch size is not existence reduced or measured. There are a number of modest but effective practices you can implement to kickoff getting the benefits of reducing batch size.

3-6 points: You are reducing and/or measuring batch size. Yous may already be seeing the benefits of reducing the size of the batches you work in, but you take the opportunity to make further improvements.

7-nine points: You have reduced your batch sizes and are probable to exist seeing the benefits! Can you have information technology to the next level?

How small-scale should nosotros make our batches?

The ideal batch size is a tradeoff between the cost of pushing a batch to the next stage (eastward.g. the toll of testing a new release) and the cost of belongings onto the batch (e.m. lost acquirement).

As this graph shows, the interplay of transaction price and holding cost produces a forgiving bend. Y'all don't demand to be precise. Information technology'south hard to brand batches as well pocket-size, and if you do, it'south easy to revert. This means we tin employ the following heuristic:

Tip: Make batches every bit pocket-sized as possible. Then halve them.

In guild to make minor batches economic we need to reduce the transaction costs. Many of the practical tools for reducing batch size accomplish this by increasing transparency, making communication easier, precluding the demand for handoff, and automating and hardening processes.

Let us now look at some of the key tools for managing batch size in Agile. Nosotros can:

• divide stories into the smallest increase of value
• work on vertical slices of a system
• employ Test Driven Development
• increment the frequency of deployment
• co-locate teams.

Split up stories into the smallest increase of value

Having larger stories in an iteration increases the risk that they volition not be completed in that iteration.

To minimise the size of our user stories we need to zero in on the least we tin can exercise and all the same evangelize value. Post-obit the INVEST mnemonic, our stories should be:

Independent
Negotiable
Valuable
Estimable
Southwardmall
Testable

This means we should always write small stories from scratch. Sometimes, however, our planning for the iteration volition identify a story that is too large. In this instance nosotros need to dissever the story to isolate the must-haves from the squeamish-to-haves. Overnice-to-haves can include:

• steps in the workflow
• business rules
• options or flexibility
• comprehensiveness
• automation of existing transmission processes
• user interface refinements
• performance refinements.

When looking for ways to split a story we can cheque for:

• conjunctions (e.g. 'and', 'or') every bit they suggest there are two parts to the story
• additive adverbs (e.g. 'additionally', 'secondly') for the same reason
• superlatives (e.g. 'best', 'easiest') as these indicate a gold-plated pick
• equivocal terms (e.g. 'several', 'ordinarily') as these are signs of open-concluded stories
• aspirational terms (e.chiliad. 'ideally', 'should') as these elements are clearly non-essential.

Oft large stories upshot from a want to provide our users with the best possible experience from solar day one. But giving them immediate value and improving on this incrementally provides greater value overall.

Richard Lawrence has produced a detailed and useful set of resources on how to dissever user stories.

Work on vertical slices of the system

One specific way we can focus on the smallest increase of value is by working on vertical slices of the system.

Development of a organisation that is divided into multiple architectural layers (such as Information, Services and User Interface) tin proceed one layer at a time, or information technology tin can continue across all the architectural layers at one time; we can work horizontally or vertically.

Information technology is mutual for projects to start at the bottom, completing all the work required to build the total production at each level. The work is so handed off to the squad that specialises in the side by side layer. This means that you lot can only deliver value when the peak layer has been completed. It also results in a very large batch, with bottlenecks at each stage.

The alternative is to have a unmarried cross-functional, multi-disciplinary team and piece of work on all the layers of a tightly-focussed piece of functionality. This volition be a potentially shippable increment of our software that tin either be deployed or beta tested. We tin facilitate this by setting up a DevOps environment that integrates evolution and IT operations.

As an case of a vertical slice, you might showtime a basic east-commerce site with this minimal functionality.

Select purchase > Log in > Pay

Later on stories can and so expand this to:

Select purchase > Log in > Review purchase [new] > Pay > Get confirmation e-mail [new]

Equally we add new functionality nosotros can refactor or build reusable components to keep the code clean and efficient.

In dissimilarity, if you work in horizontal slices, you might design and build the database you need for a full solution so motility onto creating the logic and expect and experience.

Avert splitting work betwixt separate teams

We have found that splitting piece of work between multiple, split teams significantly increases project risk, especially when teams are from dissimilar organisations. Causes include increased coordination and integration of disparate work processes and priorities, more dependencies and greater likelihood of unexpressed assumptions. The bigger the batch, the more these factors come into play.

Balance intentional architecture vs. emergent design

For larger projects, yous need to notice a balance between intentional compages and emergent design. Some architectural choices are all-time planned, especially when particular options offer clear advantages or to make information technology easier for teams and tools to work together. In other instances, it is best that the architecture evolves as nosotros larn more about user needs.

Employ Test Driven Evolution

In Test Driven Development (TDD) yous first write a test that defines the required consequence of a pocket-sized piece of functionality. You so write only the code needed to fulfil the test. Side by side, you run all tests to make certain your new functionality works without breaking anything else. Lastly, you lot refactor to refine the lawmaking.

Focusing on small units and writing only the lawmaking required keeps batch size small. This makes debugging simpler. Information technology also makes it easier to read and understand the intent of the tests. Additionally, focusing on the effect keeps the user needs front of heed.

Nosotros can further embed user needs in the procedure via Behaviour Driven Evolution (BDD) and Acceptance Exam Driven Evolution (ATDD). These brand the business value more transparent and simplify communication betwixt the business product owners, developers and testers. In BDD we start with structured natural language statements of business needs which get converted into tests. In ATDD we practice the same affair with credence criteria.

To continue the batches of code small equally they motion through our workflows we can as well employ continuous integration. Once we've refactored code and it passes all tests locally we merge it with the overall source code repository. This happens as often as possible to limit the risks that come up from integrating big batches.

Increment the frequency of deployment

Even if nosotros integrate continuously we may all the same get bottlenecks at deployment. We may as well discover that our work no longer matches the technical surround or user needs. Indeed, we can define a completed batch equally one that has been deployed.

What nosotros observe in practice is that the more than ofttimes nosotros deploy, the ameliorate our product becomes. In Build Quality In, Phil Wills and Simon Hildrew, senior developers at The Guardian, depict their experiences like this:

"What has been transformative for the states is the massive reduction in the amount of time to get feedback from real users. Practices like Examination Driven Development and Continuous Integration tin go some way to providing shorter feedback loops on whether code is behaving every bit expected, but what is much more valuable is a short feedback loop showing whether a feature is actually providing the expected value to the users of the software.

"The other major benefit is reduced risk. Having a single characteristic released at a time makes identifying the source of a trouble much quicker and the decision over whether or not to rollback much simpler. Deploying much more than frequently hardens the deployment process itself. When yous're deploying to production multiple times a day, at that place's a lot more than opportunity and incentive for making it a fast, reliable and shine process."

Co-locate teams

Having your whole team working together means you can talk contiguous, facilitating pocket-size batch communication with real-fourth dimension feedback and clarification.

It is especially important to have the Product Owner co-located with the team. If the Product Owner isn't available to clarify requirements they tend to accumulate. This increases batch size, too equally slowing downwards the piece of work. If concrete co-location isn't possible and then virtual co-location is the side by side best thing. This means that Product Owners ensure they are responsive and available, fifty-fifty if they are non physically present.

Co-location tin also mitigate risks acquired by having multiple, divide teams. Once again, if physical co-location is impossible, we can maintain pocket-size batch communication by bringing teams together for regular events such daily standups, and by setting expectations for responsiveness and availability.

How does reducing batch size reduce risk?

Large batch projects inherently increase risk by increasing the investment at stake; putting more time and coin into the project makes the consequences of failure all the greater.

Conversely, smaller batches reduce the risk of a projection failing completely. Reinertsen explains the mathematics like this. If you bet $100 on a coin toss you have a 50/fifty take a chance of losing everything. But if yous split that into twenty $5 bets, the odds of losing it all are 1 over 2 to the 20th. That's one chance in a meg.

When we reduce batch size we get feedback faster. This limits the gamble nosotros volition waste fourth dimension and coin edifice something which doesn't meet users' needs, or which has many defects. Even if our product delivers what our initial discovery piece of work specified, in a big batch project we risk releasing software that has been rendered obsolete by changes in engineering and user expectations.

Practice makes perfect, and smaller batches likewise produce shorter cycle times, meaning nosotros exercise things like testing and deployment more regularly. This builds expertise, making delays or errors less likely.

Smaller batches likewise reduce the chance that teams will lose motivation. That's considering they get to come across the fruits of their labours in action. Endeavour is maintained at a consistent and sustainable level, reducing the overwhelming pressure that tends to build at the cease of big batch projects.

Big batches, on the other paw, reduce accountability because they reduce transparency. In a big batch, it's harder to identify the causes of delays or points of failure. Every bit motivation and a sense of responsibility fall, so likewise does the likelihood of success.

Because we deliver value sooner, the cost-do good on our project increases. This reduces the hazard of an application becoming de-prioritised or unsupported.

Summary

While working in modest batches seems counterintuitive because you lose economies of calibration, the benefits far outweigh the downsides.

Moreover, the formula for determining the ideal batch size is simple. We make them equally small-scale equally nosotros can. Then we halve their size again.

We do this considering small batches let united states of america get our products in front of our customers faster, learning as we go. Equally a result they reduce the gamble that we'll become over fourth dimension and budget or that we'll deliver depression quality software.

By ensuring nosotros deliver working software in regular brusk iterations, small batches are a key tool in our Agile software evolution arsenal.

Further reading

How to split a user story — Richard Lawrence

How reducing your batch size is proven to radically reduce your costs — Boost weblog

Why small projects succeed and big ones don't — Boost blog

Beating the cognitive bias to make things bigger — Boost blog

Test Driven Development and Agile  — Boost web log

The Active Risk Management Guide

Guidance	Case studies & resources
Introduction to projection run a risk direction with Active	Agile hazard management checklist — check and tune your practise
Effective prioritisation
Reduce software evolution take chances with Agile prioritisation	Reducing gamble with Agile prioritisation: IntuitionHQ case study
Increasing transparency
How Agile transparency reduces project hazard	Hazard transparency: Smells, Meteors & Upgrades Board example study
Limiting work in progress
Manage projection hazard by limiting work in progress	Reducing WIP to limit risk: Blocked stories example study
Reducing batch size
How to reduce batch size in Agile software development	Reducing batch size to manage risk: Story splitting case report

What Is A Major Benefit Of Reducing Batch Size?,

Source: https://www.boost.co.nz/blog/2018/11/reduce-batch-size-agile-software-development

Posted by: messerhusad1974.blogspot.com

Share this post