Understanding SDLC Is Important For Startups
SDLC stands for Software Development Life Cycle.
Before we start talking about SDLC, let’s make something clear – all companies are technology companies.
Let me give an example to explain what I mean by that.
Even if you have for example an apparel company and your products are not digital, your startup company stands no chance against a competitor that is automated, has superior tracking tools, tested and constantly adapting digital marketing strategy, and updates inventory in (almost) real-time. Did I mention design? Not at all, because it is not possible to survive solemnly on being different.
Many founders will argue that their company is not a technology company, and that would be wrong. A lot of the current technologies are so deeply embedded in our lives, that they become completely transparent or invisible. This is how you recognize a technology has passed the adoption period and is now a mainstream technology. Cases like this make us forget or at least require recognizable effort on our side to see and understand what technologies are required, being used, or enable our ideas for business.
Explaining the Software Development Life Cycle
Software development, like any other complex project, takes proper planning, preparation, feasibility tests, braking complex tasks to smaller manageable ones, and delegating them to teams and team members.
Software Development Life Cycle (SDLC) is the process that helps to define tasks and follows through the execution of a project.
SDLC is a framework, a methodology for planning and controlling the creation of software. The goal is to guide the client and the creators of the software during the process of implementation, to ensure the client will receive what they asked for with the features defined in the beginning. It also tests and verifies the feasibility of the initial idea.
Software Development Life Cycle is not a management methodology. It is not about management, but rather offers the framework of steps for the development team clearly defined in work phases.
Phases of software development include analyzing user requirements, designing the software, implementation, documenting and testing what has been implemented, and finally – operating and maintaining the software.
As you can see, this diagram shows 5 distinct steps of the process. Having them defined and communicated to the stakeholders in the project helps understand what needs to be done and why.
Describing SDLC Phases
Let’s review the phases if the Software Development Life Cycle and explain each step of the process.
Requirements and analysis
This is the starting point in the whole series of steps. In this stage of the SDLC, we gather requirements from the client, analyze the feasibility of the idea, draw the path of future functionalities, compare with existing products and look for new better ways to implement the initial idea.
When you are creating a product that is an implementation of your own idea, then you are the client for the end product. Usually, it is up to the founder, in this case, to put everything on paper. This is a difficult process, because it requires you to think of all potential needs and details, branching and essentially formalizing the business rules. Ideally, it will also include some mock-ups to limit the creativity of the developers and be closer to your original product idea.
The outcome of this step of the SDLC should be a requirements document. It can be a product description document too if you are a more of the visionary type.
Here are some of the techniques you may use to gather requirements and perform the analysis:
- Customer Interviews (one-on-one or group)
- Facilitated Sessions
- Joint Application Development
- Gather and Review Proposals
- Brainstorming Sessions
This is the phase where you need to have senior-level technology people to help you translate your requirements into a more formal form, ready to be presented to your software development team.
This phase includes making decisions about technology stack, input, and output, forms and database structures, etc.
The outcome of this phase is usually a set of documents and flowcharts that present your business flow, the user journey with your application, data structure, and storage needs. Creating wire-frames is usually a very good idea, as it will force you to think through many details and help you find potential gaps in your idea, business process, or documentation.
This phase is where you finally start building your software. It translates specs and requirements into real code.
In this phase, you are engaging with your software developers and your role is to make sure the requirements are adequate and software developers are building your software according to these same requirements.
It is always the case that when the actual development starts, adjustments to the requirements are going to happen. This doesn’t mean you did something wrong during the first two phases. It simply is the nature of building and managing complex systems – when you start building it, you learn more about the problem and the tactical decisions and approaches need to be adjusted.
It is important to mention that the work by your developers needs to be closely supervised and reviewed often so that components created by different people can and/or still function when combined together. Modern software development encourages building small components, so your solution is maintainable and salable, but this increases the maintenance complexity and requires strict interface protocols to make sure you are building a coherent product.
The testing step is part of the SDLC to ensure you deliver a quality product. You need dedicated resources to verify and approve whatever your software developers created. Errors in logic, workflow, design, usability – all of this needs to be verified and confirmed before you ‘go live’.
Here we are going to go back to the documentation and requirements gathering outcome because these are the documents your QA engineers will use to create test cases. These same documents you created in the very beginning will now play the role of providing checkpoints and use cases to the QA team to verify and approve the application before it gets into customers’ hands.
This usually is an iterative process. QA engineers find issues and they return the product back until they are satisfied with the quality and the adherence of the resulted product with the requirements.
Stakeholders are welcome to participate in this phase (acceptance testing), where they ‘sign-off’ and eventually accept the proposed solution.
Deploy and Maintenance
This is the last phase of your process, but you can see it as the first step of another set of processes that you will need to adapt now.
This part of the Software Development Life Cycle refers to the last ‘push’ to get the product out of the factory and put it for real use.
Deployment simply means you are going to move the tested and verified code from your internal servers and environment to your production-grade servers and make it publicly available. Once you do this, you will need to monitor and maintain your application.
Any application needs to be monitored for issues, user requests, performance issues, environment implications, etc. This phase requires a different type of talent and your company will most likely need someone with DevOps experience.
Understanding SDLC Requires Much More Than Following These Five Phases
Now that we revised the phases of the Software Development Life Cycle, I need to tell you that this is not enough to build software. SDLC is a framework, but it is too high-level to be able to execute only with this knowledge.
It is true you need requirements, but once you gather them, things are not as easy as described by the SDLC.
The current industry-accepted methodology for software development is following the Agile methodology for project management. But Agile is not only or solemnly a project management methodology. Even calling it a ‘project management’ methodology is probably not completely correct.
In other words, SDLC is ideal to understand what the software development process looks like on a very high level. But when you start on an actual project, you will realize things are not as cleanly separated as described by SDLC.
For example, the usual process goes more like iterating trough many, smaller SDLC processes. You gather requirements, but they are not too detailed because the problem is not very well-known or it is a use case test. Developers start with these relatively vague requirements and produce some functionality, which gets tested and presented to the customer. The customer provides feedback, documentation is added or changed and the next iteration of codding is done, including testing.
Once the customer is happy with the proposed solution and the QA engineers are satisfied with the quality of the product, it is deployed to production.
Deployment to production can also vary in very wide ranges. From once a month, to once an hour for bigger and more experienced teams.
Software Development Life Cycle is an important methodology and an important framework. It describes the very high-level understanding of what phases are included in the process of building and delivering software.
There needs to be good alignment between your project management tools and methods with the SDLC to be productive. There are many and different project management approaches. You as a founder need to choose the one that fits best your company culture, your needs, and also depends on the size of your project.
Use the SDLC process to evaluate tools, team needs, and scope definition. This methodology gives you a powerful set of tools to develop quality software fast and be cost-effective.