Understanding the Software Development LifeCycle

Think about all the apps and programs you use. Could you give even a wild guess as to how many you use on your computer, your phone, at work, and in your personal life? It’s a lot, isn’t it? Now, have you ever considered how all of those apps and programs come to life? Behind every button click and every feature, there’s a carefully developed process that takes ideas and turns them into reality. The process is called the Software Development LifeCycle (SDLC). Understanding the SDLC can change the way you see the technology you use every day.

WHAT IS THE SOFTWARE DEVELOPMENT LIFECYCLE (SDLC)?

The SDLC is a process that is used by software developers that defines the steps to design, develop, test, and deploy software. The process is structured,  and it ensures that the end product, the software, meets quality standards and the requirements that the customer set out. There are seven phases or stages the SDLC, and I’ll talk about each of them in turn, but here they are: Planning, Analysis, Design, Implementation, Testing, Deployment, and Maintenance.

WHY SHOULD NON-PROGRAMMERS CARE ABOUT THE SDLC?

Understanding how software is made from beginning to end can offer several benefits to even average technology users. Knowing the basics of software development can help you more effectively troubleshoot many common issues you may have with your own devices and applications. You can also communicate better with tech support or the app developers if you have a bit of understanding of how the stuff was made, because you’ll be better able to explain problems and understand solutions. Another benefit is being able to make more informed decisions when you’re choosing software, or when you’re evaluating a new technology, because you’ll better understand their capabilities and limitations.  Furthermore, and this one is dear to my heart as a security professional, understanding software development can increase your awareness of security practices, which can in turn help you protect your personal data and your privacy. Additionally, understanding how software is developed can foster a greater appreciation for the technology you use every day, because you’ll recognize the effort and the complexity that’s involved in creating software. Finally, even having a very basic understanding of software development can open new job opportunities for you, or maybe enhance your current job by being able to integrate new technology into your current usage.

WHAT IS THE PURPOSE OF THE SDLC?

There are many reasons for implementing the SDLC process in a software development program. For one thing, it provides a clear, structured framework for developing software. The framework is the underlying form around which the program is built, sort of like an armature that provides the basic shape for a sculpture. It provides a step-by-step guidebook for each phase, so that all the necessary actions are taken, correctly and in the appropriate order. SDLC also supports risk management. By planning and analyzing the requirements early in the development process, the framework helps stakeholders (we’ll look at stakeholders in a few minutes) identify risks and address them, which can reduce the chances of the project failing. SDLC also includes thorough testing phases to make sure that the software meets quality standards and works like it’s supposed to. Efficient use of time and resources is another benefit of SDLC, giving the parties opportunity to see to efficient resource allocation, budgeting, and scheduling. Additionally, using SDLC makes sure that all the stakeholders, especially including the developers, the testers, and the clients have the same understanding of expectations and results. One of the most important values in using SDLC is creating a repeatable process. Each step in the cycle will earn its place, and the whole process should work the same way every time it’s used. The added value of a repeatable process is that it can pave the way for future projects of similar nature.

WHO IS INVOLVED IN THE SDLC?

If the project is being done for an outside customer, the customer is one of the stakeholders in the project. The customer has consulted with a business analyst to gather and analyze the requirements and get those requirements translated into technical specifications. However, the customer won’t be communicating directly with the development team. That task falls to the Product Owner. The Product Owner gathers the requirements from the customer and represents those requirements to the product team and makes sure that the development aligns with the requirements and the goals of the customer. There’s also the Project Manager, who coordinates the whole project by managing the timelines, required resources, and all the communication among the team members.  The Team Lead takes management of the technical aspects, such as guiding the development team on implementing solutions. There are the actual developers who write the code and build the software based on the design and the functional requirements. They’re different from the designers, who create the user interface (UI) – the part of the program you see – and the user experience (UX) – what happens when you click here, menus for navigation, etc. – designs. Along the way, the testers and quality assurance engineers test the software to identify bugs to fix, and ensure that it meets the quality standards. Bringing all that work together is the job of the system architects. They design the overall architecture of the program and ensure that it will meet the technical and business needs outlined at the beginning of the program. Finally, we bring in the dev ops engineers, who will be responsible to manage the deployment, integration, and maintenance of the software.

WHAT ARE THE STAGES OF SDLC?

The first stage of SDLC is Planning. The Planning stage has seven steps. They are identifying problems and needs, brainstorming solutions, market research, user feedback, feasibility analysis, prototyping, and planning. A well-structured program brings all of these steps into play, but many developers have tried skipping steps and found themselves having put a lot of work into an app that doesn’t provide the return they had hoped.

Planning:

Often, the thing that drives a new program is a problem or need that software can fix or improve. A lot of apps on your phone started out to solve a problem that the developer had, but market research or customer feedback can also provide a driver for a new or improved program. Occasionally we see a piece of software or application that feels like it was create simply to make use of available technology – what we call a solution in search of a problem to solve.

Once the problem or situation is recognized, someone holds a brainstorming session to come up with possible solutions. These sessions encourage creating thinking and exploration. Some of the ideas will spin off new projects of their own, and some will be discarded as unworkable.

The next step is overlooked more often than it should be, but it’s market research. Market research helps validate the idea by evaluating its viability  (can it even be done), what are some potential impacts, and its alignment with market needs and business objectives. Market research includes analyzing competitors to see what they’re doing well and what they’re doing poorly, and it also includes understanding user preferences.

The planner also needs to engage with potential users to gain feedback on the overall idea. This can provide valuable insights on whether the project should move forward, shift direction, or be abandoned. However, user feedback can also help the planner find ways to improve or refine the whole concept.

A feasibility analysis is part of the planning stage. The planner needs to know if the project can be achieved with the resources available, technically and financially. It’s much better to know this at this stage than when extensive amounts of time and money have already been invested and cannot be recovered.

Prototyping comes next. The planner gets someone to create prototypes or mockups of the software. The prototypes and mockups help visualize the software and how it works. The potential users engaged in the previous step can see the vision and anticipated functions, and they can offer suggestions for improvements.

The final Planning step is also called Planning. It’s the process of defining the scope of the project, setting the timelines, and allocating the resources. It sets the foundation for the whole development process.

Analysis:

In the Analysis stage, the developers determine what the software needs to do. They gather the requirements through a series of steps, and I’ll lay them out here.

First, developers meet with the client or client’s agent, end-users, and business analysts. Each of these parties may have different needs and expectations of the software, and it’s important to get the needs and expectations out in the open early in the project.

Developers then conduct interviews and surveys with people who may use the software. The interviews and surveys can help the developers gather detailed insights into their requirements and pain points.

Developers then analyze the market trends and competitors’ products. These provide context for what users actually want, but they can also help the developers identify other features that may make their offering new, different, and better.

Next comes use cases and scenarios. Developers need to visualize how the users will use the software – how they’ll interact with it. From this they can make sure they’ve included all the necessary functionality.

Once again, we see prototyping and mockups, this time for a wider audience and with different inclusions. During this step, all stakeholders get their chance to give their feedback on the design and functionality, and it’s still early in the process.

Now it’s time for a requirement analysis. They take all the information they’ve gathered so far and create a clear and detailed Software Requirements Specification (SRS) document. This is going to be a guide for planning and verifying that what they’re creating is what they are supposed to be creating.

Before they get to work, the final Analysis step is validating and verifying. They review the requirements with the stakeholders to make sure that what they have decided to do is accurate, complete, and feasible.  

Design

Now the developers get to plan how the software will look and work. This is not the coding process. That comes later. This is the part of deciding what happens when you do stuff – click a button, enter data, etc.

Once again, the developers start with gathering requirements. They need to know what the stakeholders want the software to do. Again, it’s not about what the problem is to be solved, but how they want the software to behave when the users do stuff.

Next is the User Experience (UX) design. The designers create wireframes and user flow diagrams that map out the user journey. Wireframes are basic visual representations of a web page or the interface of an app. When I say basic, I mean really basic, like line drawings. They use these drawings to figure out the layout of the elements on the page you see, and then to direct the flow of processes with each available action.

From the Experience design, we move into the User Interface (UI) design, where we start to see detailed mockups and prototypes. UI design focuses on visual aspects of the product, like layout, colors, and typography. These designers have a lot of data at their disposal to draw from, that helps them create a design that best serves the purposes of the product and the consumer.

Architecture Design will be done by the system architects, and this is where all the previous work really comes together. They will plan the total structure of the software and define how everything will interact. They’ll also select the most appropriate technologies and frameworks to build and install it all on.

Now it’s time for the developers to create the detailed technical documents that outline the software’s functionalities, the data structures that it will need, and any algorithms that will drive results from user inputs. Remember, we’re still in the design phase.

From those documents, the developers build a prototype, or they may create a Minimum Viable Product (MVP). Either of these will allow for testing and feed back at an early stage, so that they can refine both the design and the functionality.

Throughout the process, as decisions are required, the team will solicit feedback and reviews, but at the very least, they need the feedback at the point where the prototype or MVP is completed. That feedback at this stage is very important to be able to make any necessary adjustments or refinements to align the final product with the original intent.

Implementation – writing the code for the product

“Write the code” is easy to say, but it’s never easy to just “write the code.” Learning to code is a complex process, and it’s easy to develop bad habits or not develop good habits. For those of us that aspire to be coders, going the self-taught route might allow us to learn sloppiness, and that sloppiness will create sloppy code. Some of this will be alleviated by a few good practices.

One of these is using an Integrated Development Environment (IDE) rather than a text editor to write the code. While a text editor will work in most coding languages, an IDE provides tools and features that streamline the code-writing process. Syntax highlighting can help the developer quickly see certain syntax uses. Code completion can reduce repetitive typing. But perhaps the most useful and valuable feature in an IDE is the debugging tools that help a developer find and eliminate coding errors easily, rather than having to scroll through thousands of lines of code.

Another good practice to facilitate a good end product is to follow coding standards. Adhering to coding standards and best practices helps ensure consistency and readability, which makes easier to write and maintain code. It’s important to remember that, as time passes, it’s highly unlikely that the person who writes the code will be the person who maintains the code later. Future developers will need to be able to understand what the intent was behind each piece in the code. This might also include writing “clean code.” By that, I mean that the code is readable, and that the variable names are meaningful. The functions that the code calls should be short and focused. The coding process should avoid unnecessary complexity.

Developers also break down the big problems that the code should solve into smaller, manageable tasks. By making the process more “modular,” the team can simplify the coding and debugging.

Developers can also make use of existing libraries and frameworks that contain the functionality and process. They can avoid “reinventing the wheel” if something already exists that does what they need it to do. They can also avoid incorporating errors and problems, as well as saving time and effort. Additionally, there are tools and scripts that can automate formatting, testing, and deployment. Finally, they also “refactor” the code periodically, which is the process of restructuring the code without changing the behavior of it. They may reword or add comments (pieces of text that aren’t processed as code, they serve to explain a process or function), reduce a complex segment, or enhance maintainablility.

Testing

There’s no point in putting in all this work for a program or application if it doesn’t work like it’s supposed to. That’s where the testing stage adds value to the whole project. Developers have several methods they use to make sure the software works correctly – and predictably.

Developers write tests for the individual components and functions to make sure each one works right. This is called Unit Testing, and these tests are automated, and developers run them quite frequently throughout the process. It’s great if each of the components works correctly, but they also have to work together, and that’s where integration testing comes in. Finally, the system as a whole has to be tested, and this includes the functional testing (does the software work) and the non-functional testing (how well does it work).

After the internal testing is complete and the development team is satisfied, real users test the software in an environment that is as close to real-world application as possible. This is called User Acceptance Testing (UAT). There are often differences in how a program works in a development environment and how it works in actuality, and that’s what this level of testing is designed to find.

Regression testing checks to make sure that the software still works like it’s supposed ot after changes or updates. Performance testing puts the software under different conditions, like thousands of users trying to access it simultaneously, low bandwidth conditions, throwing large amounts of data at it, and seeing how it goes over a long period of time. The development team also seeks to identify and fix security holes before deployment.

As changes are introduced during any phase of the development, the change goes through a code review. Peers look over each other’s code so that they can catch errors and improve the quality of the code before it gets merged into the main codebase. It’s always better to have several sets of eyes on a piece of code.

Deployment

Now it’s time to release the software to the users, but the code that the developers have been writing won’t be what you as a user see. The software has to be packed into an installer or an executable file, which contains all the necessary files and computer instructions for installation.

How does a user get that program for their use? Part of the development plan includes a distribution channel. Users can download the software from the developer’s website, or through a distribution platform like the Google Play Store, the Apple App Store, the Microsoft Store. The developer can provide the program through physical media like a CD/DVD or a USB (thumb or flash) drive, but this has become a very uncommon method. Finally the developer can make the program available as a Software as a Service (SaaS) offering. Users can access the software through the cloud without having to download anything to their device.

The development plan also includes licensing requirements, or a subscription plan. Activation keys or online verification ensure that only authorized users can access the software. This isn’t always about money, though. A company may produce a piece of software that is only for use by their employees, in order to protect their company proprietary information.

The users install the software if necessary, following the installation instructions provided by the provider, and this process can be completely automated, or it may require some manual steps. After the deployment, developers provide updates to fix bugs, add features, and/or improve security. Most are delivered at least semi-automatically, but some will require some type of user action.

Maintenance

Are we through? Can we all go back to sleep now? No, I’m afraid not. There are going to be updates periodically, and that’s a good thing. There will often be fixes, updates, and improvements to the software, and if there aren’t it’s not a piece of software you can depend on.

Most important are the Security Updates. Developers don’t intentionally write insecure code. They write it as securely as they can, but they don’t know all the ways an attacker can exploit something if nobody’s ever done it. Sometimes vulnerabilities are discovered by white-hat hackers, sometimes by attackers, and sometimes by the development team. Security updates are deployed as quickly as possible and should be installed as quickly as possible. Not only could a vulnerability cause problems to that program, but it may sometimes provide a pivot point to other areas of the device.

Bug fixes are next in importance, because a program is not worth its price and effort if it doesn’t function properly. Compatibility updates are also important, because we’ve often seen a piece of software break functionality with an operating system update. Feature updates and performance improvements are part of the maintenance, and they’re part of what you pay for when you buy a program or application.

Finally, if you love a particular feature of a program, or if you hate the way something makes you take extra steps, or if you can think of a way it could be improved, find a way to let the developer know. You can usually find a contact form at the developer’s website, but the app stores also provide a way to leave feedback. When I’m reading reviews for software I’m looking at, the developers often respond with suggestions for temporary workarounds, or a comment that they’re working on implementation of that feature. If you find something doesn’t work, they need to know that as well. Even though they’ve done extensive testing, they haven’t tested it under the exact circumstances that every single user will experience. You may find the one thing they couldn’t think to test.

YOUR TURN

I hope this explanation has been useful in helping you understand how an idea born from someone’s pain point to something you can install and use. There are some specificities I may have missed, like how an app integrates with a website, like a bank app or a mail app, using Application Programming Interfaces, because that gets deeper into the development process than I’m qualified to take you at this point.

But, now that you have a glimpse into the life of software development, why not take it a step further? Next time you use your favorite app, take a moment to think about the stages it went through before it reached your screen.  If you’re curious to dive deeper, check out the links below. If you have questions or comments , drop a comment below—I’d love to hear your thoughts! And don’t forget to subscribe for more insights into the tech world made simple.

What is SDLC? – Software Development Lifecycle Explained – AWS (amazon.com)

10 Reasons Why Software Development is Important ? – GeeksforGeeks

SDLC Roles and Responsibilities: The Complete Guide (djangostars.com)

6 Benefits of Software Development Life Cycle (SDLC) (intelivita.com)

From Idea to Reality: The Essential Steps of Software Development — ITRex (itrexgroup.com)

How to Define the Software Development Requirements of Your Project (orientsoftware.com)

What Is an IDE? How It Helps Developers Code Faster (g2.com)

Software Development Life Cycle (SDLC): A Comprehensive Guide – MOHA Software

My photography shops are https://www.oakwoodfineartphotography.com/ and https://oakwoodfineart.etsy.com , my merch shops are https://www.zazzle.com/store/south_fried_shop and https://society6.com/southernfriedyanqui.

Feel overwhelmed by tech? ‘Your Data, Your Devices, and You’ is your go-to guide for mastering the basics of online security and device management. Ideal for anyone who wants to use technology safely without becoming an expert. Find it on Amazon.

Playlist for this writing session:

Old and Wise – Alan Parsons Project; Livin’ Thing – Electric Light Orchestra; Keep the Car Running – Arcade Fire; After the Flood – Lone Justice; Oh Darling – Supertramp; My Best Friend’s Girl – The Cars; Psychobabble – Alan Parsons Project; Lipstick Sunset – John Hiatt; Cruel to be Kind – Spacehog; Right Here, Right Now – Jesus Jones; Mrs. Potter’s Lullaby – Counting Crows; Somewhere Over China – Jimmy Buffet; Blame – ABC; Fade Into You – Mazzy Star; Red Dress – Maia Sharp; Just What I Needed – The Cars; Loser – Beck; The Scientist – Coldplay; Never Coming Down – Spacehog; Jump – Madonna; Imaginary Lover – Atlanta Rhythm Section; Born This Way – Lady Gaga; Have a Little Faith in Me – John Hiatt; Sanctify Yourself – Simple Minds; Nothing but Flowers – Talking Heads; In a Daydream – Freddy Jones Band; Space is the Place – Spacehog; Somebody Calling – Robin Trower; Down Home Town – Electric Light Orchestra; To Be a Millionaire…Was it Likely – Spacehog; Shake ‘Em On Down – North Mississippi Allstars;  Kind and Generous – Natalie Merchant; Surfin’ U.S.A. – The Boys; Feels Like Rain – John Hiatt; Wonder – Natalie Merchant; Go To Get You Off My Mind – Southside Johnny and the Asbury Jukes; Wild Wild Life – Talking Heads; Tennessee Plates – John Hiatt