The Agile software development process is an adaptive methodology based on a fragmentary, repetitive approach. The agile methodology allows for changing requirements throughout the development process and requires constant feedback and communication with the client. A dedicated, cross-functional team of ours works on a fragment of the product over a period of time (a sprint). The team members organize, track and coordinate their work with tools like Jira and communicate with the client regularly.
The Agile process is usually used for long-term, extensive projects or projects with undefined end-goals. The goals are cleared out during the development process and because of Agile’s flexibility, changes to requirements can be easily adapted earlier in the project.
The project leader coordinates the work of the development team, takes care to avoid bottlenecks and organizes the team in order to meet the deadline of each iteration.
As opposed to the waterfall process, at the beginning of each sprint, the development team basically decides what can be achieved in the timeframe and starts working on a series of features and a working software product which, at the end of the sprint, can be installed in a production environment. The flexibility of the Agile methods allow development teams to adapt the flow to the needs of the project. The general goal of each Agile development method is to adjust to changes and deliver working software as quickly as possible.
Agile projects require regular communication and feedback from the client and the team members during the whole project, so the same mistakes will be avoided in the next iterations.
Regular communication with the client brings more attention to visual details and technical performance.
The project is broken down into smaller tasks and they get distributed amongst the team members. This allows them to focus on high-quality development, testing and fixing bugs faster.
- Parts of the software are delivered at earlier stages, so the customer can get value sooner and give feedback
- Changes and fixes are easier to adapt, even at later stages
- Tasks are always up-to-date, so fewer resources are wasted
- Faster turnaround times
- Issues and bugs are detected faster and are easier to fix at earlier phases
- Based on QA feedback, developers can improve their coding skills
- Customers, PMs, developers and testers constantly communicate with each other
- More attention is payed to technical excellence and good design
Agile has a lot of advantages but it’s important to be aware of the disadvantages.
- Sometimes documentation gets piled up or sidetracked, so it’s harder for new members to get into the project
- It’s more complicated to measure than in waterfall because it happens across several cycles
- The sales cycle is more complicated because the prices can’t be fixed at the beginning of the project
- When a developer runs out of work and is a part of a dedicated team, he/she can’t work on a different project because he/she will be needed soon
- You need a long-term vision of the project/product and actively work on communicating it with the client
- In some cases of software deliverables, especially larger ones, it is difficult to estimate the effort required at the beginning of the development process
- The project can easily slip off track if the client’s representative is not clear on what outcome they want
The Waterfall methodology is based on a sequential, linear process and is the most popular variation of the systems development life cycle (SDLC) for software engineering and IT projects. It is simple and easy to use. Sometimes, a Gantt chart is used for planning the start and end dates of the tasks. In this model, phases do not overlap, therefore each phase must be completed before the team proceeds to the next phase. If the team needs to go back to a previous stage, the whole process should start from the beginning. Such action costs a lot of In order to avoid that or the project being discarded, the requirements, concept and technologies are very well defined and documented beforehand.
This type of software development model is usually used for small and unchanging projects with well defined requirements and the technologies are well known and not dynamic. It’s not suitable for projects with unclear end goals and requirements or long-term projects.
The results of each phase are reviewed in order to determine whether the project is on the right track and whether to continue or to discard the project. The QA testing begins only when the development is done. Less customer interaction is involved during the development process. A demo product can be presented to the client only when the product is ready.
There are seven stages in waterfall and they must be done successively.
1. Define Concept and Requirements: At the first stage, the concept and business goals are discussed and defined with the client over several meetings. Risk are analyzed by the project leader. When all is clear and documented, a rough estimation and evaluation of the project is made.
2. Planning: When the concept is clear and the requirements are specified and documented, a team is formed and a course of action is planned. That includes defining projects scope, deadlines and deliverables.
3. UI/UX Design: This step is not included in cases when the client comes with their own design. Otherwise, the design team first creates the architecture of the projects and then they proceed to colors, shapes and animations. The design specifications are then used in the coding phase.
4. Development: This is where the actual coding begins. Before the actual programming, the design is reviewed and evaluated, so the team can understand and decide how to proceed.
5. QA Testing: When the development phase is complete, the product needs to be tested for any visual and functional errors. Some projects require user acceptance testing.
6. Delivery: Once the testing is complete and all errors are fixed, the final product is delivered to the client.
7. Maintenance: After the final product is released for use, the customers may find additional issues. The development team needs to resolve or modify the software in order to continue to be effective.
- Easy to manage and use: The linear, inflexible sequential pattern of the waterfall methodology makes it easy to use and requires in-depth-documentation. It’s also easier to manage and control because of the specified deliverables and deadline of each phase.
- Discipline: Focusing on the requirements and design before coding can reduce the risk of a missed deadline. Because every phase has a start and end point, it’s easy to share progress with the client.
- Detailed documentation: Every phase of the process requires documentation, which results in a better understanding of the logic behind the code and tests. This can come in handy for future projects and if the client needs to know more details about a certain phase.
- High visibility: A demonstrable product can be presented to the client and project manager after every finished stage.
- Changes are hard to implement: The biggest disadvantage of the waterfall methodology is how it deals with changes. Once a phase is completed, it’s very difficult to go back or bounce between stages, even if there are unexpected changes. If the testing phase is reached and there is a feature missing, it is very difficult and expensive to go back and fix it. Sometimes this may result in discarding the whole project.
- Collecting and defining final requirements can be challenging: The first phase of the waterfall process is to talk to customers and stakeholders and pinpoint all requirements and technical specifications. This is usually tricky because often times, customers don’t know what they want early on. This results in change requests as the project progresses.
- Working Software is not delivered until late: For the actual coding to begin, two to four stages have to be completed beforehand. Therefore, clients are not able to see working software until late in the cycle. This brings high amounts of risk and uncertainty.