Software Development Process from the Inside: Everything You Need to Know
You know, there’s a building site next to our office. Here’s what it looks like from the outside: someone has chosen a place, surrounded it with a fence… and that’s it. Now, they’ve been here for a long time. Occasionally, something is making noise inside. What are they doing in there? Where is the investor’s money going? Can they finish the work faster?
When you contact a software vendor, you don’t want to be faced with similar questions and guesswork about the progress of your project. To achieve maximum efficiency, it’s better to know all the ins and outs of the software development process and their interdependence.
This article aims to explain the stages of software development, their interdependence, and how we at Django Stars manage development teams and processes at the product development stage. No more unexplained terms and opaque “fences”. I’ll share our experience from the inside.
The SDLC: What Is the Software Development Life-Cycle, and Why Does It Matter?
At what point can you say that the “life” of your software product began? Actually, this moment comes before you even contact the developers. That’s because the Software Development Life Cycle (SDLC) covers the entire period from when the decision to create a software product happens until the project closes (i.e., the full stop of the product exploitation).
A practical note follows from this:
The development of your product and its timing/cost can be greatly influenced by the decisions you make in the early stages, sometimes even before contacting a software vendor.
SDLC is typically divided into several main stages. Their number and sense might slightly vary according to the specifics of the project and the approach of a particular company. We’ll cover them in detail below.
It’s worth noting here that each stage includes a wide variety of accompanying activities and processes, such as, for example, documenting, audit, verification, and organizational tasks.
Also, each stage brings its own results, which you can take into account for further product development. Likewise, when constructing a building, you can transfer the results of geological research to the architect and receive drawings that another contractor can work with.
Various activities come to the fore depending on the current stage of the SDLC. So let’s take a closer look at these stages.
Stages of the SDLC
The way the various processes in SDLC interact with each other affect the amount of time and effort spent on development, the quality of the product itself, its timeliness, and eventually its success among users.
Compared to construction, you don’t need trucks filled with bricks before you decide whether the building will be monolithic. Geological research should be carried out before this. And while this research is in progress, it would be premature to hire drywallers. First, you need to check that the constructed building turned out nicely, is sustainable, and was built according to the project specifications. Only then you can expect that tenants will want to live in it.
For simplification purposes, I’ll only describe the main phases of software engineering that we at Django Stars include in the project life-cycle between signing a contract and NDA with a client and maintaining the launched product.
To better understand each stage, we need to have a clear vision of the processes that each stage contains, as well as what comes into and what should come out of each process.
But first, I’d like to say a few words about the SDLC roles that the main participants accept.
- When a business asks for a product to solve a specific problem, they need to define a Product Owner, or, as clients often refer to them, the “Requirements Owner.” It’s the name of the person who completely understands the clients’ needs from the business perspective and is able to transfer this knowledge. Note that this doesn’t match the common meaning of “business owner,” but those who are responsible for interacting with the development team.
- On the vendor’s end, a Project Manager manages the process and ensures delivery of artifacts, i.e., material representations of the work or the value obtained during the appropriate stage.
- A certain process at each stage also has an owner, i.e., a responsible person.
Let’s now look at the main stages of the Django Stars project life-cycle.
The Discovery Phase
In this step, the main task for the vendor’s team is to do a comprehensive investigation of the project requirements, domain, and all of the client’s business specifics. Returning to our building analogy, this stage is when you choose the house type and explore the construction site.
The Project Manager should receive the initial product idea from the Product Owner (business representative) and the information about the fixed agreements from the sales department. Once they have complete information, they prepare the team members and introduce them to the project.
To avoid downtime, we strive to execute as many processes as possible in parallel:
- The Business Analytics process includes documenting opportunity and win conditions, system design assumptions, and others.
- The UX/UI investigates the client’s domain, defines the target audience, creates the customer journey map, and presents the design concept.
- The Quality Assurance process consists of developing the project component structure, defining the test strategy, and preparing documentation.
- The Software Engineering process includes investigating the business requirements and domain, preparing an architecture overview (by the Solution Architect), considering the tech stack, preparing estimates, specifications, and other documentation.
- The Project Management process will be confirmed by a Discovery phase report (prepared in collaboration with the Solution Architect and Business Analyst), which will inform the Product Owner about the results of the phase.
Note: To properly execute all these processes, it’s critical to provide the vendor with as much information as possible: your business presentation, gathered requirements, early prototypes, specification, competitor information, customer portrait, etc.
The Pre-Development Phase
This is the setup phase. It includes knowledge transfer from the sales department and business analyst to the project team, reviewing documentation, and setting up the development process. If we were building a house, now we would be evaluating the blueprints and occupying the construction site.
- The Project Manager coordinates the team’s organizational activities, such as communication with the business, backlog scoping, etc. The Backlog is a list of forthcoming tasks that will be performed according to priority.
- The Project Lead helps them by taking on the coordination of technical activities such as environment configuration, 3rd-party services integration, etc.
- The Business Analyst (for preparing the Project Estimate) and CTO (for setting up Github, the server, Mailgun and Mailtrap) also connect to the processes.
- The Project Lead, Project Manager, and the team are supported by the Solution Architect, who writes a high-level solution document named Architecture Overview and checks the BA’s estimates.
- The QA engineer, who is responsible for project quality, prepares testing documentation.
As a result, after this phase, the vendor’s team is prepared to move to the first loop of iteration in Development.
The Development Phase
This is the stage in which the actual code should be created, tested, and deployed for User Acceptance Testing. At Django Stars, we manage these processes according to the guiding principles of the Scrum framework.
We’ll discuss popular project management frameworks and the reasons why we chose Scrum in more detail below. For now, I’ll only tell you that project creation occurs through successive iterations. They might be represented by a prototype, MVP, MMP, MLP, MDP, and MAP, which are most often not complete but are still a fully workable product that will be gradually improved from one iteration to another.
This also reminds us of building a house. You can’t totally focus on building just one wall, then adding another, and so on. First, you need to build a simple but whole place to live in. Then you start decorating it, strengthening, finishing, and adding floors or annexes. But from the beginning and at every stage, this building must be livable. Likewise, the software product should be usable and allow you to collect real feedback as soon as possible.
The process owner, in this case, is the Project Manager, who manages the iteration process to deliver a product increment to customers. The Software Engineering process consists of writing code and tests and documenting the code. The UX/UI designer creates interface design solutions that solve the concrete problems of the customer after discussing them with the team and the Project Manager. QA engineer provides a test report.
The job of the Product Owner (the client’s representative) is to articulate the business requirements for the product as clearly as possible, to help prioritize the Backlog (i.e., the list of features to be implemented), and to accept the work when an item is satisfactorily delivered. Throughout the development process, try to build a transparent relationship between the business and the vendor to achieve a shared understanding of the problems and solutions.
What Is the Best Approach to Software Development Management?
Many different approaches to the software development process have been invented to better meet certain goals. In each of them, the same processes can be organized in their own way. Here are the most popular examples:
- Waterfall, where each process starts only after data prepared during the previous one is received.
- Scrum, where you divide the whole project into short-distance sections, resulting in a workable product that improves with each iteration.
- Kanban, where current tasks move from one column on the board to another, and you limit not the time but the number of tasks in each process.
From experience, we’ve found that Scrum is the most suitable for our clients and us. Let’s take a closer look at why we use it in our web development.
Agile and Scrum
One of the main tasks of project management is to achieve the most efficient use of resources and an even distribution of the workload for each team. For example, the testing team should not sit idle waiting for the development team to provide code to test.
Scrum can be classified as an Agile software development framework, which means it’s one of those approaches that build on the Manifesto for Agile Software Development and its twelve principles. Rather than treating various software development jobs as steps in a long sequence, Agile turns them into collaborative processes with the involvement of developers, management, and customers.
The development process in Scrum, as scrumguides.org describes, is divided into short periods (in Scrum, they are called “sprints”). At Django Stars, they are 10 working days long, i.e., about two weeks. Each sprint is an iteration that gradually brings the draft project closer to the planned one.
Here are some of the advantages we like in Scrum:
- Shared product understanding. All the development teams constantly communicate with each other and the business representative to manage requirements. This helps reorder the product Backlog, so the most important items move to the top for the next sprint.
- Parallel processes. Using our Scrum approach, we strive to avoid downtime in situations where some team roles may be blocked by others. The team members can use their spare time in the development process to get deeper into backlogged tasks (this process is called Grooming). And they can request additional information from the business party in advance.
- Predictability. When using Scrum together with Jira, we can estimate every single task in story points and predict the number of sprints this particular project will take, based on our known working speed. This allows our client to plan their budget and deadlines more precisely.
However, there are also some disadvantages:
- Requirements frequently change, which can complicate project budgeting. Moreover, you must ensure that new requirements don’t conflict with the existing project architecture.
- The willingness of all parties to interact is required. For work is run smoothly, the development team must be both highly qualified and customer-oriented. The business party must be in touch and promptly answer emerging questions.
- Endless adjustments to requirements can delay the project (typically, because there’s no limit to perfection).
The experienced team should be aware of these issues in advance and not let them play a prominent role in the development process. In our blog, you can find a few tips and secrets of effective work planning in Scrum.
After the development phase, it’s time to launch.
The Launch Phase
This phase includes the preparatory work that needs to be done before a public roll-out (prod release) of the application. The “house” is almost ready, and you’re going to invite the first tenants to view it.
The Project Manager process can be performed after receiving the QA engineer report on the quality of the application build before a release and official confirmation from the Product Owner (“Requirement Owner”) that the application satisfies their business expectations and requirements. The necessary tasks are: inform the team, develop a launch plan with the team, and make a Project launch checklist. In parallel, the Software Engineer process (preparation work, bug fixing, polishing before release) and the QA process (final tests) are underway.
The Power of the Built Processes
We’ve examined from the inside what processes take place on the “construction site” of a software application. The main takeaway from the reading I’d like to offer is that software development is a complex but coordinated process. The various stages require input from other participants. Therefore, it’s critical that the business and the software provider are on the same page via strengthened communication.
In the development phase of the SDLC, the main challenge is finding an effective balance to reduce time and money costs. After all, different approaches to the software development process are just tools that can be adapted to meet the goals of a particular project.