The keys of iterative and incremental development

25 Apr 2022

How do you develop a project iteratively and incrementally, and what does it mean to do so? Lesmes López, Agile Delivery Manager (ADM) at Codurance, answered these questions in a meet-up on 5 April.

First, he compared a project to a giant elephant and underlined, as the main idea, that the intention is to embrace or "eat" this project in all its dimensions. The task does not seem easy and can even be overwhelming when we see this enormous animal (project) in front of us. That is why López explains that the key is to "slice the elephant", i. e. making slices of the project and that each one provides real value for the user.

Starting point

First and foremost is the collaboration of the team. Each team member may have a different vision of how to carry out the project or what course of action is best. Without a cohesive team, the project may lose pragmatism and agility. López explained that for the project's success, "all the different members of the project must be involved as early and as much as possible in the conception of the project. From inception and development to construction and deployment".

He highlighted three important elements to be taken into account; the value of the project for the company, the usability for the users and the real capacity of the project to be achievable from a technological point of view. 

To achieve this collaboration, López highlighted that it is important to create a unified User Story. Which he defined as something that can be explained and understood in a unified way by all team members: a joint vision.

The key points in creating this User Story are the conversation, the confirmation and the card: the conversation is the most important part, where team members should take time to explain their individual ideas. The next stage would be to bring all versions together and shape them into a single version that everyone agrees on (confirmation).

Finally, the card is about capturing that idea to have it as a reference throughout the project that can be looked at whenever necessary. 

Framing iterative incremental development

Before explaining the keys to an iterative and incremental method, López asked the participants if they considered that a methodology such as SCRUM was sufficient to implement a project in an iterative and incremental way. He then explained that it was not, as methodologies such as SCRUM provided a structure but not a way of carrying out processes.

Then, what does iterative and incremental development refer to? It's about delivering value as quickly as possible and building on each delivery. "Through fast and continuous deliveries we allow the user to interact with the service and learn their real needs and how best to deliver them, adding value with each new release," López defined.  

Within incremental iterative, a key concept is the difference between decomposing and slicing. Decomposing refers to working on individual parts of a project, but then when you try to put them together they have no connection to each other and do not facilitate usability for users. This can lead to communication breakdowns in the team or unnecessary independent testing.

López recommended that it is best to divide the project into vertical slices, that is, to make deliveries that include all the components of the service in order to have a real test of what the product is going to be so that the user can start using it. This way, in the next delivery, functions will be added or removed based on a real interaction between the users and the product. This requires collaborative work between the development teams, not individual deliveries according to work areas, but a single delivery from which value continues to be added as a whole. 


To elaborate a more precise definition of iterative and incremental development, the ADM divided the two concepts and described: "Incremental by itself would mean that we take a functionality from the architecture, finish it and make a release. Then we do another incremental for other functionality and we do another release. And so on, until at the end we have all the functionalities that we have been incrementing one by one".

Meanwhile, the concept of iterative "starts from the fact that we have created a base of all the functionalities and what we do is iterate what we have and improve it. Each one of these iterations would be a release," he explained.

But in iterative and incremental development, "we mix these two concepts so that in each release the functionalities evolve in different parts, depending on what has real value for the user," he said. In other words, there is an increase and iteration of the functionalities, not in a linear way, but adapted to the real needs that are detected when the user interacts with each of these deliveries.


Key Tools

Having clarified the purpose and methodology, we moved on to more specific tools. López presented User Story Mapping (USM), a visual exercise that helps development teams to define the project's path according to the approach that offers the most pleasant user experience.

He explained that the most important part of the USM is the backbone as it defines the story of what the user wants to achieve and what steps they have to take to get there, that is, the narrative flow of user journeys. "Once we have the backbone identified, i.e. the tasks that define what the user needs, from there, we identify downwards how to develop that task. These will be the user stories that we will work on, breaking down a functionality into different functionalities that complement the main task," he said. 

Therefore, your USM is made up of the backbone, the working skeleton with that first release that contains all the minimum parts to complete the user flow, and then the following releases that are adapted to the amount of functionalities that you want to give to that user per delivery. Always prioritising what gives real value to the user. 


Based on an outline by Jocelyn Goldfein, López emphasises the importance of keeping in mind that release processes will differ according to the technology of the service and the business model. If it is a web or cloud service, it is possible that these releases can be executed more quickly than in an on prem product.

This approach also allows us to consider the cost of making a mistake in our product. For example, delivering a new version of an app, users downloading it and then warning them that it is not the correct version has a greater impact than if we are making a release on a website and in a short time we can fix or modify the error. 

He ends his presentation with a reflection on deploy and release, in which he states that handling deployments and releases in a decoupled way brings several benefits. Among them, it allows to verify that the pipeline works correctly and that other dependencies are not affected, it also avoids the risk of a negative impact with the users because the release is only made when everything is in place and tested. He presented two tools that help us achieve this, Dark-Launching that allows us to deliver to only a part of the users and feature flags that allow us to deploy only a part of the functionalities at a time when it is considered optimal.

After the presentation, the participants of the meetup took part in a kata to practice what they had learned. Based on a hypothetical case, they developed a User Story Mapping in groups and generated a first release.


Iterative and incremental development is based on rapid and continuous deliveries of real value to users. It is essential that each member of the team is involved in the conception of the project and that a clear and unified vision of the actions to be carried out and the objectives is generated.

The deliveries should not be independent according to work areas, but vertical slices deliveries that make sense to the user and that he/she can start using from the first one. Based on this interaction, subsequent releases will be generated to help improve the user experience, prioritising the functionalities that are most needed to complete the tasks. The key is to balance iterations and increments according to the real needs that are detected at any given moment. 

Stay up to date with meetups:


Software Crafters North:

Codurance Craft Events Barcelona:

Software craftsmanship Lisbon: