We live in an era where technology has evolved beyond mere entertainment to become an integral part of our lives. Applications such as Waze, Uber, Bolt, Outlook, Gmail, WhatsApp, Spotify, and Apple Pay have become essential in our daily routines. However, for these applications to be so effective as to make a difference in our lives, it was necessary for companies to understand society's ‘pain points’ and invest time and resources in developing those apps.
Something fundamental was needed throughout this process: communication. That is precisely what we are focusing on today – how communication influences the software lifecycle and contributes to Agile development.
First and foremost, it's important to understand communication in its purest form. Communication is nothing more than the exchange of information between two or more individuals. The secret of successful communication lies in how the other party receives the information, which is a direct result of the clarity with which it is conveyed – the clearer, simpler, and more detailed, the easier it is to interpret and understand.
How to apply communication to software development?
We understand now what communication is, but the question remains: if this truly is the foundation for Agile software development, why do some products not achieve as much success as others?
There are, of course, many aspects that contribute to the success or failure of a product, but the fact is that the kind of software that reaches the top and becomes a reference, like the ones mentioned earlier, knew how to apply communication very effectively throughout the development process.
This approach goes way beyond daily meetings or other ceremonies – it is necessary to listen to what the customer expects, understand the competition, and put ideas into practice.
This process depends on the level of interaction among each team member and, especially, among key individuals whose responsibility is to ensure that each member understands what needs to be done and how it should be done.
The secret lies not in what is written but in how the information reaches its recipient. Especially in the development field, where we often work remotely, it is crucial to ensure that others understand what needs to be done. Therefore, constant and detailed communication should be prioritised.
For effective communication throughout the software development process, the following participants are fundamental:
- Product Owner (PO)
The person responsible for understanding what customers need and why they need a specific functionality. The PO should gather precise and detailed information – the more information, the better.
- Business Analyst (BA)
Just like the PO, the BA also needs to understand customers’ expectations and is responsible for integrating the business dimension with the technical dimension of development. The BA creates use cases, and the better the clarity in writing each case and its steps, the better developers can understand what is needed, ensuring development aligns closely with customer expectations.
- UX/UI Designer
The “magician” who brings dreams to life. The UX/UI designer is responsible for creating prototypes that ensure the product’s brand and identity, offering a pleasant, innovative, and memorable customer experience. This is where the customer becomes fascinated by the product, whether by its simplicity and innovation or by the ease of using the software.
- Quality Assurance (QA) Specialist / Tester
The QA plays one of the most crucial roles in this flow, ensuring a product with as few errors as possible, by performing tests that simulate how the customer thinks in various scenarios, whether manually or automated. The QA specialist, after an extensive battery of tests, provides the verdict on whether the product is ready or not to reach the customer.
In addition to these key characters, it's also important to mention Back-end and Front-end Developers, Architects, Site Reliability Engineers (SRE), and others who work behind the scenes. They leverage their technological background based on information conveyed by the other members to ensure lightweight and fast applications.
Notice that the software development process goes way beyond just listening to the customer and immediately start developing – it requires going through some “filters” that explore possibilities for the product to exceed customer expectations. For this, communication needs to be as simple and clear as possible.
Agile methodology and processes
Now that we've identified the key characters, let’s understand how to “connect” them. For this, we need to delve into an extremely efficient and well-known methodology in the world of software development: the Agile Manifesto. Over the years, this document has become the bible of Agile development and is supported by four essential values:
- Individuals and interactions over processes and tools
Maintaining communication throughout the software development process is crucial to reduce potential issues and bring people closer. Tools and processes are important but should be used pragmatically.
- Working software over comprehensive documentation
Fully functional software is more important than strictly following the plan. Working, error-free software is the best indicator of excellent work. Clients pay for results, not well-crafted plans that may never come to fruition.
- Customer collaboration over contract negotiation
The customer should be part of our team and always play a leading role. The purpose of this relationship is collaboration. Just as a team works towards a common goal, we also must make sure our decisions are entirely aligned with the customer’s objectives.
- Responding to change over following a plan
Using feedback received during the process, along with scenario analysis, is essential for providing quick responses to how operations are going. However, this does not exempt us from having a plan, which should be ready for any changes.
Within the Agile methodology, there are various frameworks that contribute to this fluid development process. Let's look into two of the most popular.
With a name derived from rugby team concepts, Scrum helps structure the team, defining roles and behaviours through its three artifacts: product backlog, sprint backlog, and product increment. Briefly explaining them:
- Product backlog
A dynamic list of features, requirements, adjustments, and corrections acting as a preview for the sprint backlog.
- Sprint backlog
First and foremost, a “sprint” is the term used to define the development cycle of the product, typically lasting 30 days, always with the goal of delivering something that adds value to the customer. Therefore, the sprint backlog is the list of deliverables – use cases and bug fixes – selected by the team to be delivered during the sprint.
- Product increment
Often identified as “Done”, the increment is what has been completed and is ready for the next product release.
For this process to work, certain rituals – known as “ceremonies” – must be performed to ensure all “gears” are aligned and functioning perfectly. Among the ceremonies are Planning, Daily, Review, and Retrospective:
The meeting where all the characters mentioned earlier gather to define the items to be worked on during the sprint, based on each item’s priorities.
15-minute meetings held every day of the current sprint to discuss progress, obstacles, or any other aspects that may affect delivery.
A meeting where all members present what was achieved in the last cycle, and the PO decides and formalises what will enter the list for the next review.
The moment when the team gathers to analyse the positive and negative aspects that occurred in the last development cycle and, from there, make improvements.
A methodology that is also part of the Agile universe and aims to monitor and control the development process. With this approach, we can track the status of each task and ensure efficiency in delivery, as each character can work on the same task at different times.
An excellent tool for Kanban, widely used, is Jira, which facilitates this entire process and provides other benefits such as support for automated testing, Continuous Integration/Continuous Delivery (CI/CD), among others.
The Kanban workflow operates as follows:
- After the stages have been defined for a specific task, and after the BA’s requirements and UX-created mockups, the task moves from the backlog to the “In Progress” state, where back-end and front-end developers work.
- It then moves to the “Testing” state, where QA specialists conduct a battery of tests.
- It finally reaches "Finished”, where after the review, the PO can move to “Done” everything that meets the expectations and is ready for implementation.
This process may seem somewhat time-consuming, but we have seen that it is well-detailed and encourages all team members to interact. This facilitates understanding of what is being done, allows knowing the status of deliverables, and ensures that with each new sprint, the team is stronger and better prepared, based on retrospective feedback.
Throughout this article, we have seen how clear and precise communication can influence the efficient and swift development of software. It's worth noting that interaction needs to be constant throughout the entire development of a software product (as advocated by the Agile methodology), and the easier it is to interpret, the better the results and delivery will be.