Software Delivery Excellence – a Bird's Eye View on The Process

Making a timely decision during software development is an important aspect of software delivery. Some of the important stages of the software development cycle are:

• Requirement finalization
• UI prototypes
• Design
• Development
• Testing
• Deployment

Let’s discuss important processes that should be monitored on a day-to-day basis. Those will help us to understand the situation better. They will also help to take important decisions.

Requirement Finalization

Quality requirements will be the foundational step for software quality. There are a few important parts in requirement finalization. Before delving into the details, one important task that drives the requirement is release themes. We need to finalize the release theme correctly based on the customer pain points or market trends, depending on the type of project. Once the release themes are finalized, clearly break down the release themes into appropriate epics.

The next step would be to come up with good user stories. This is, again, a very important part of requirement finalization. These must be very small in size, defined with non-ambiguous acceptance criteria. Generally, my recommendation would be to ensure the size of the story is well within the 5 user story points. This is including all best practices in the doneness checklist. After coming up with the quality user story, to achieve the quality of requirement at a user story level, we should follow the below steps:

• Requirement format – The most useful format in Agile is GWT (Given/When/Then) format. If we write the requirements in GWT format, then it can be easily used for automation as well.
• The user story should be smaller in scope – Don’t put too many business rules into a single story. Split them as many as possible functionally.

In this phase, it is important to ensure the requirements are ready on time. Otherwise, the rest will go wrong. We should ensure the requirement is ready for the upcoming sprint.

One of the practices that has helped us is to finalize the next sprint stories ahead of one sprint. This way the upcoming sprint can kick off smoothly. These can be done as a research spike in previous sprints to finalize requirements.

UI Prototype

UX Prototypes play an important role in software development. It takes second priority after requirement gathering. To ensure all user stories planned to go as per plan, it is important to make sure UX prototypes are ready in advance. If the UI prototypes are developed by the UI team, then we should make sure they are ready before the first sprint of a release.

In my experience, developing UI prototypes as part of development sprints would not be recommended. UI development needs lots of focus like UX, user feedback on UI, etc. Before we start actual development, UI prototypes should be ready. If the UX is not ready, then all your development gets queued up and it might invite too many reworks for the application.

Design

In Agile, the design should be done on an incremental basis. The first day of the sprint should be utilized for finalizing designs. Sprint team should get together to brainstorm on the design and agree on the design. We must capture quick design diagrams and attach it to the user story.

In the design phase, as the user stories are smaller, there will be a tendency among developers to start development immediately. We must emphasize brainstorming and create designs for the user stories in that sprint.

Development

Once we have the user stories clearly defined and UI prototypes are ready for the development team, development can begin smoothly without any hurdles.

To ensure, the dependents are ready in advance. We could create a few research spike stories. Also, we can have a few stories required for requirement definition and UI prototypes in the previous release. In case of a new project, it should be sprint 0 activity.

As part of development, there are many tasks should be done to ensure, we are accomplishing acceptance criteria’s of both functional and nonfunctional requirements. 

In development, below important tasks should be monitored vigilantly in different stages of development.

• Ensure all doneness acceptance criteria are defined as tasks in each user story.
• Development and QA should work hand-in-hand in discussing requirements, designs, and impacts.
• All defects found in the sprint must be closed in the same sprint.
• If the code repository is in Git/Bitbucket, setup pull requests for code review and ensure all check-ins go through code review with their peers or tech leads or architects.
• All best practices should be done right the first time. Do not encourage the culture of making dirty work first and then correcting them for best practices.
• As part of the user story, ensure unit tests and functional automation are also complete.
• All new code has gone through the static code analysis and make sure all the bugs are fixed right away.

In our process, we have made the static code analysis bugs as build failures. Developers will not be able to check in code those does not comply with static code analyzer rules.

Testing

Testing starts from day 1. We must involve QA teams from the stage of finalizing release themes, requirement finalization, and UI prototypes. They should be part of the process from beginning to ending. There should not be a mindset of involving QA only for testing. The tester would be sitting next to the developer and test it incrementally. This way, we would not be drawing any line between development and QA. QA should not get biased with development approaches by working closely with them. For getting better outputs, there should be validation of the software development work across all the stages.

A couple of practices those must be watched carefully are:

• Ensuring development and QA works very closely from the stage of requirement definition.
• Involve QA in code reviews, this will help QA to do white box testing. It will be possible to compare the test cases with those business rules written in the code. Validating that if there any conditions those are added in the code but it is not covered in test cases. It will be vice versa as well. There could be some test cases those are not covered in the code. This way, there will be an understanding between development and QA, producing better quality code. No major bugs will be in the code.
• QA also need to follow modularity while designing test cases. There should be re-usable test cases instead of duplicating test cases across multiple user stories or modules. A simple example would be about test cases required to validate data entry rules and security vulnerabilities. These will be used for all data capturing screens. So when a test plan is designed, these unit level test cases should be added for the test plan.
• QA will be working very closely with development, so QA will have a very good view of the code. One of the best practices to identify the dependencies and code coverage would be through code churn based testing. Please refer my article for more details on code churn based testing.

Deployment

Deployment should also start with architecture-level discussion. The logical architecture diagram provides lots of input to deployment. There should be continuous inputs from the development team to the Deployment team. Some of those are:

• Virtual directories
• Access Permissions
• Shared locations
• Configurations
• Security aspects

Watch out

A few important tasks those must be done as part of the deployment process:

• Ensure the deployment process is the same in developer deployments, staging deployment and production deployments.
• All deployments should be automated including configurations. There could be separate configurations for different environments. However, it should be automatic based on the environment.
• It is important to make sure deployments have zero downtime. To achieve this, the Deployment process must be brainstormed and considered from architecture and design phase till the development completes.
• Ensure application performance monitoring is set up for all environments.
• Ensure preparation for failures, thoroughly validate rollback testings as well. If something goes wrong during deployment, we must have a strategy to rollback builds.

I have tried to summarize above some of the important best practices those must be followed in the software development process. These will help to deliver top quality release by giving importance to each stage of development. They are just guidelines and must be validated before applying them based on your type of project, team, and infrastructure available to you. However, if they are followed, it will surely make the process of software development more robust and accurate.