The 5 D's of the Software Development Process; How To Make Meticulously Crafted and Relevant Tech

October 5, 2020

Software is such an integral part of our lives that it has become invisible to us. It keeps our home thermostats at the perfect temperature, wakes us up on time, starts the morning pot of coffee, that great playlist, and shares that maybe not so great morning news. It can help you keep track of your exercise routine, check your emails, and make sure that the engine in your car is running efficiently.

What Is Software?

Software is a program that enables a computer to perform a specific task.

There are four primary types of software,

Systems software - This runs the computer hardware and the application programs. It is the platform on which other computer programs can execute. Examples include:

  • Android
  • CentOS
  • iOS
  • Linux
  • Mac OS
  • MS Windows
  • Ubuntu
  • Unix

Programming software - These are tools that developers use to create, debug, and maintain other programs and applications. Examples include:

  • JavaScript
  • SQL (Structured Query Language)
  • Python
  • Java
  • C#

Application software - Applications are what people are most familiar with as they use them every day on their phones to share photos or listen to music.

Malicious software or malware - Just as the name indicates, malicious software is developed by cyber attackers to access or damage a computer or network. A common alternative description of malware is a "computer virus."

What Is Software Development?

At its simplest, software development is a set of steps used to create a program.

A more comprehensive definition of software development is "the process of conceiving, specifying, designing, programming, documenting, testing, and bug fixing involved in creating and maintaining applications, frameworks, or other software components. Software development is a process of writing and maintaining the source code. In a broader sense, it includes all that is involved between the conception of the desired software through to the final manifestation of the software, sometimes in a planned and structured process. Therefore, software development may include research, new development, prototyping, modification, reuse, re-engineering, maintenance, or any other activities that result in software products."

The Evolution Of Software Development

One might wonder, what were the beginnings of the now-ubiquitous software that is integrated into every aspect of our lives. Its origins lay in people seeking ways to work more efficiently.

As early as 2,400 BC, humans found a means to count large sums quickly by creating the abacus, or first calculator, to perform arithmetic processes.

Millenia progressed without much change in the world of computing. During the mid-1800s, English mathematician Charles Babbage proposed a general-purpose mechanical computer, and his colleague Ada Lovelace recognized that the machine had applications beyond pure calculation. She is regarded as one of the first computer programmers.

Alan Turing's "Enigma Machine," made famous in a Hollywood movie, broke German codes during WWII and was truly revolutionary. A Washington Post article shares, "He invented the idea of software. It's software that's the important invention. We had computers before. They were mechanical devices. What we never had before was software. That's the essential discontinuity: That a machine would decide what to do by itself."

In the 1950s and '60s, simple software instructions were made on punch cards with rows of dots representing zeros and ones. Reels of magnetic tape and later disks replaced them. In the late 1970s and '80s, computers moved from existing only in universities, government agencies, and large corporations. They became affordable and small enough for the average household. But as most people did not know how to program, software applications were needed to run the hardware, and ultimately, many more software developers were needed to create them.

The More Things Change

Developers of the late 20th-century most likely could not have envisioned the software programming tools available today. However, while technology has changed rapidly, what has not changed is the basic concept that the software development process must follow a logical order. This is the software development life cycle (SDLC). The SDLC began as the "systems development lifecycle" in the 1960s. Geoffrey Elliott explains in Global Business Information Technology that large corporations could use the model to manage complex business systems, data processing, and analysis.

SDLC Models

There are a variety of SDLC models that can be utilized to achieve similar outcomes. A few are outlined below, each with its own best use applications, advantages, and disadvantages.

Waterfall Model

The waterfall model, the oldest and probably most widely known, outlines steps to develop software in a logical and straightforward manner.

The steps include

  1. Engineering
  2. Design
  3. Implementation
  4. Integration
  5. Testing
  6. Maintenance

Best use cases include:

  • Short term projects
  • Pre-determined tech stack
  • No ambiguous requirements
  • Stable environments


  • Simple to use and understand
  • Clearly defined development stages
  • Suitable for small or mid-sized projects
  • Easy to set milestones


  • Not suited for complex, object-oriented projects
  • Integration is done at the very end, does not offer opportunities to identify problems in advance
  • Not suitable for large scale projects

V-Shaped Model

The V-shaped model is also known as the Verification and Validation model. It is an extension of the waterfall model and is based on a testing phase's association for each corresponding development stage. This means that there is a directly associated testing phase for every single phase in the development cycle. This is a highly disciplined model, and the next phase starts only after completion of the previous phase.

V-Shaped model steps include:

  1. Business Requirement Analysis
  2. System Design
  3. Architectural Design
  4. Module Design
  5. Unit Testing
  6. Integration Testing
  7. System Testing
  8. Acceptance Testing

Best use cases include:

  • Projects requiring accurate product testing
  • Small and mid-sized projects
  • Where requirements are strictly predefined


  • Every stage is easy to control
  • Testing and verification take place in the early stages
  • Suitable for the small to mid-sized projects with clear requirements


  • Lacks flexibility
  • Can be risky

Iterative Design

The iterative model is an agile model of design that does not start with full specification requirements. Development begins by specifying and implementing just part of the software, which is then reviewed to identify further requirements. The product is refined through various repetitions or iterations, is improved, and moved continuously towards a goal. The iterative model software development process has its origins in design thinking, and the steps that help ensure meticulous design are:

  1. Discover

This is just what it sounds like; here is the part of the process where you, your team, and, if appropriate, a tech partner will ask as many questions as possible about the desired outcome of the product. Who is the audience? What is the purpose of the tech? Who is the competition? What is the budget? Who will be handling which tasks? What are the revenue goals?

  1. Design

At this critical juncture, all of the information gathered during discovery is utilized to create a solution that delivers on your product vision and business goals using future-proof technology.

  1. Develop

Once the requirements have been translated into physical, logical, and visual blueprints, the development team creates a comprehensive project plan to organize and manage development efforts. An iterative, agile model breaks down the project into defined development cycles, often called sprints. At the end of each sprint, tech teams or partners will review the demos with stakeholders, solicit feedback, and make course corrections, as necessary.

  1. Debug

It is an unfortunate reality that all software will have bugs. The best software developers expect bugs and employ layered testing systems to find and fix them quickly. Starting at the code level, automated unit tests check that a particular piece of code does what it is supposed to do. Then, embedded directly in the sprint cycle, are functional tests that check that functionality developed during the sprint meets the specified business requirements. Integration tests, which added at the end of each sprint, check that the combined functionality of all the software components developed to date are working correctly and, again, meet all the specified requirements. Finally, when the project is nearing completion, the development team will implement User Acceptance Tests (UAT.) This involves you and your team reviewing a fully functional version of your product to ensure that everything is working as it should before the application is delivered.

  1. Deploy

The deployment of your software is exciting and may seem like you have reached the finish line. However, in many ways, it is when the next phase of your project really begins. Software will always have to be maintained. These maintenance activities can include upgrading software components to address security issues, maintain compatibility with third-party APIs, remain current with app store guidelines, etc. Additionally, as customers begin to use your application, there may be bugs that were not caught, design features that customers find confusing, or requests for other features. This is essentially the beginning of the discovery phase for the next release of your software.

Best use cases:

  • Large scale projects that need to show incremental progress
  • Projects where the main goal is defined, but details may change over time
  • When tech stack is not predefined
  • In a rapidly changing marketplace
  • When risk needs to be managed


  • Functions can be quickly developed at the beginning of the development lifecycle
  • Progress is easily measurable
  • Parallel development can occur
  • Shorter iterations allow for easier debugging
  • Easier to control the risks
  • Problems and risks in one iteration can be prevented in the next
  • Flexibility


  • Risk analysis requires the involvement of qualified individuals
  • Not well suited for very small projects
  • Can lead to Feature Creep

Regardless of the design model used, what matters most at the end of the day is that the final product is meticulously designed, relevant, robust, and well-implemented. Software development teams must be agile enough to adjust the SLDC to meet the needs of a particular customer, project, or app to achieve the desired business goals.