Skip to content
Code with Hou

Development Process

Software Development Life Cycle (SDLC)

This page describes my software development process, which is based on the Software Development Life Cycle (SDLC) standard.

SDLC is a framework that defines and provides a well-structured flow of tasks in different stages of the software development process. SDLC's benefits to an organization include:

  • high quality, functional, and well-tested software;
  • reduced development timelines;
  • reduced costs;
  • improved revenue and conversions; and
  • a high level of stakeholder alignment within and across teams;

SDLC recommends the following stages for software development projects:

  • Stage 1: Software Requirements Gathering and Analysis
  • Stage 2: Software Design
  • Stage 3: Software Implementation
  • Stage 4: Software Testing
  • Stage 5: Software Deployment
  • Stage 6: Software Maintenance & Security (Ongoing)

SDLC provides a good starting point when implementing any software project, regardless of whether it's traditional software project or a Web3 application. My approach is flexible and depending on the project's scope, we can combine, omit, or split tasks within each stage.

While many different variations of SDLC exist, I gravitate towards a hybrid of the agile and iterative SDLC models. I leverage productive tools and frameworks to reduce development costs and rapidly build and deploy applications.

Agile-Iterative Development

An agile SDLC model focuses on end user feedback and input and empowers the team to make rapid adjustments to its plan when necessary so as to be highly responsive to customer feedback.

An iterative SDLC model favors developing the software in iterations or small steps. What this means is getting a basic version of the software up and functional quickly, and then improving on it in small steps (or iterations) over multiple life cycles.

So a hybrid of these two models would typically involve initially building a Minimum Viable Product (MVP) with just enough features to meet the needs of early adopters, and then adding features over time, based on end user feedback, to make a finished application.

The rest of this document describes each SDLC stage in more detail.

Stage 1: Software Requirements Gathering and Analysis

The goal of Stage 1 is to assess the requirements for the software in development and to align the team on the specific problems the software should address.

Stage 1 addresses the following questions:

  • What are the current problems, based on stakeholder feedback, that the solution must address?
  • What are the strengths and weaknesses of the current system?
  • What are the risks involved in the project, if any, and what are the mitigation strategies for those risks?

Stage 1 Objectives

Stage 1 objectives may include, but are not limited to:

  • Gathering and analyzing information about your target market, end users, competitors, and stakeholder feedback on the problems
  • Defining the software's goals, objectives, and high-level scope
  • Compiling software requirements or developing use cases for the proposed software

Stakeholders include anybody who may use the software, such as customers, sales reps, programmers, industry or subject matter experts, etc. By gathering end user or customer feedback early on in the process, SLDC can help reduce avoidable rework and after-the-fact fixes.

In Stage 1, the team will develop a strong understanding of what problems their eventual solution should address, so that they can design an accurate, targeted solution in the next stage.

Stage 1 Deliverables

  • Non-Disclosure Agreement
  • Software Requirement Specification Document

Stage 2: Software Design

The goal of Stage 2 is to design a software solution for the problem at hand and to specify how it will work and could be implemented in the most optimal and cost-effective way possible.

Stage 2 addresses the following questions:

  • What is the best/most feasible solution to address the problem?
  • How will the stakeholder interact with the software, UX-wise?
  • Which platforms will the software run on (e.g., Apple, Android, Windows, etc.)?
  • How will we implement the solution? What changes do we have to make to our existing infrastructure (i.e., front-end, back-end, devOps, cloud) to accommodate this solution with the least amount of technical risks?
  • What security measures should we take to secure the software?
  • What is the optimal architecture for supporting the proposed software? Which architecture, programming languages, or industry practices should we follow?
  • Will the solution rely on any external or third-party modules?
  • How should the software be deployed?
  • Based on the software design, what are the project's timeline, milestones, cost, and resources?

Stage 2 Objectives

Stage 2 objectives may include, but are not limited to:

  • Creating the epics and user stories for the proposed solution
  • Developing the interface designs and UX outlines/prototypes, including gathering and incorporating stakeholder feedback on the overall software design and initial UX prototypes via usability testing
  • Researching and designing the technical architecture of the proposed software, including evaluating different technical approaches to ensure the usability, scalability, security, reliability, and performance of the solution; and specifying the system and hardware requirements, platforms, tools, frameworks, infrastructure, storage/databases, interfaces, and communication protocols needed to run the software
  • Planning the implementation of the proposed software, including defining sprints, delivery milestones, key success metrics and a rollout execution strategy; prioritizing features/functionalities based on the target audience/user persona; and creating, configuring, assigning, and tracking the programming tasks within the team's project management tool (e.g., JIRA)

By the end of Stage 2, the team will have a clear roadmap for achieving the goals of the project, and they will understand the costs and resources required to get there. They will be able to fine tune the product market fit and polish the overall design of the product before a single line of code is written, thereby saving time and resources.

The team adopts a project management methodology (e.g. Scrum or Kanban).

Stage 2 Deliverables

  • Software Specification Document, which consists of the Design Specification Document, Functional Specification Document, and Technical Specification Document

Stage 3: Software Implementation

The goal of Stage 3 is to translate the software design into source code.

Stage 3 is typically the most time-consuming part of the entire life cycle, as developers would often need to return to this stage if any bugs or issues occur in the subsequent SDLC stages.

Stage 3 addresses the following questions:

  • How can the project be divided into specific programming tasks that can be handled in parallel by multiple developers (if handled by a team)? Who's going to work on what? (based on existing each developer's existing capabilities)
  • What file structure/nomenclature, code styles and practices should the development team adopt?
  • Does each function work correctly on a unit level?
  • How can code changes be tracked?
  • Are there any development tasks that can be automated (e.g., writing scripts to automate deployment) to increase the team's productivity?
  • What knowledge gaps exist within the team? How can these knowledge gaps be efficiently filled? (e.g., pair programming, documentation)
  • How can the team ship often and with confidence?

Stage 3 Objectives

Stage 3 objectives may include, but are not limited to:

  • Setting up and optimizing the dev team's development environment, including establishing proper coding guidelines for the whole development team and programing tools as well as setting up a Source Code Management tool (e.g., Git) and process
  • Developing code for the frontend, backend, and infrastructure provisioning using the chosen tech stack and integrating them seamlessly into the application.
    • Various kinds of tests, such as system, integration, unit, and acceptance tests, may be automatically applied to the source code throughout this stage.
    • A continuous integration and deployment pipeline may be set up to enable the team to ship code often and with confidence.
    • The frontend may need to be integrated with a blockchain-based backend.
    • The team performs regular code reviews and meets to discuss weekly progress, demo and get feedback on their work, and strategize on pre-launch and beta releases.
  • Writing documentation (e.g., user guides, troubleshooting guides, FAQ's, video tutorials)
  • Deploying the software to a test/staging environment

In Stage 3, the development team will be able to produce organized and consistent code that's easier to understand and to test during the next stage.

Stage 3 Deliverables

  • Frontend/Backend/Infrastructure Source Code
  • Technical Documentation
  • Frontend/Backend/Infrastructure Deployment to Test/Staging

Stage 4: Software Testing

The goal of Stage 4 is to test the software continually to ensure that errors, bugs, and other issues are identified and fixed while the software is being built, rather than after the software goes live.

Stage 4 addresses the following questions:

  • What are the most important parts of the software to test?
  • Does the feature(s) work as expected and integrate seamlessly with the rest of the application?
  • Which user workflows should the QA team manually test?
  • Will the system to able to handle potential changes in traffic or database load that might occur when the software goes live?
  • Are there any final mistakes that need to be fixed before releasing the software to production?

Stage 4 Objectives

Stage 4 objectives may include, but are not limited to:

  • Working with the QA team to manually test different parts of the application to spot any defects or bugs and to see if the software matches user expectations (i.e., User Acceptance Testing)
  • Performing load test(s) on the system via a simulated production environment

Stage 4 minimizes the number of bugs and glitches in the application so that end users will be more satisfied and will be more likely to continue to use the application.

Stage 4 Deliverables

  • Software Quality Assurance (QA) Report

Stage 5: Software Deployment

The goal of Stage 5 is to deploy the software to the production environment so that end users can start using the software.

The software may initially be released only to a limited segment of the user population, and after a while, if all goes well, be released to the entire user population.

Stage 5 addresses following questions:

  • Does the new software match the users' expectations?
  • Should the new software be released to the entire user population or just a segment of the user population?

Stage 5 Objectives

Stage 5 objectives may include, but are not limited to:

  • Deploying the software to the production environment
  • Setting up event monitoring to be notified of real-time changes in the system
  • Executing the rollout strategy

Stage 5 will help the team become confident that the software would not present any major issues to end users after it is deployed to production and that the software would meet user expectations.

Stage 5 Deliverables

  • Frontend/Backend/Infrastructure deployment to production
  • Event monitoring dashboards
  • Rollout execution

Stage 6: Software Maintenance & Security

The goal of Stage 6 is to ensure that the software continues to work as expected in a secure and performant way for end users.

The deployed software needs to be monitored continuously for errors, up-time and performance. You may want to conduct A/B tests to learn what works and what doesn't for users so you can continuously improve on the end-user's experience.

Stage 6 addresses the following questions:

  • What are end users saying about the software? What additional requests do they have for the software?
  • Is the software secure from cyber-attacks? Do the current security measures offer sufficient protection from DDoS attacks?
  • Does the application load quickly? What else can be done to optimize performance?
  • How can any third-party modules be kept up-to-date?

Stage 6 Objectives

Stage 6 objectives may include, but are not limited to:

  • Communicating and gathering feedback from end users via customer support channels (e.g, phone, email, chatbot)
  • Maintaining and monitoring the application performance and security using various tools (e.g., SpeedCurve, AWS services)
  • Adding initiatives to the product roadmap based on end user feedback (e.g., updating third-party libraries)

Stage 6 will ensure that the software would continue to improve over time as the team continues to iterate on the software by incorporating end user feedback and optimizing the application infrastructure.

Stage 6 Deliverables

  • Software Maintenance & Security Report
  • Software Maintenance & Improvement Proposals

Read about my smart contracts development process.