Software companies operating under quality management systems face a critical challenge: how do you maintain consistency, traceability, and quality while managing the complexity of software development? The answer lies in a structured design and development process that follows the PDCA (Plan-Do-Check-Act) cycle. This iterative approach, combined with rigorous verification and validation methods, ensures that software products not only meet technical specifications but also fulfill their intended purpose in real-world environments.
Table of Contents
- Understanding the PDCA cycle in software development
- The four phases of PDCA in software
- Design and development planning requirements
- Capturing design inputs
- Design outputs and documentation
- Verification methods in software development
- Validation methods in software development
- Configuration management’s critical role
- Design reviews, verification, and validation
- Managing design changes
Understanding the PDCA cycle in software development
The PDCA cycle serves as a foundational framework for continuous improvement in software development. Originally conceptualized by Walter A. Shewhart and later popularized by W. Edwards Deming, this iterative four-step method provides a structured approach to managing software projects from conception to deployment.
In software development, the PDCA cycle aligns closely with agile development and iterative software design. Each iteration represents a complete PDCA cycle, moving through planning (requirement analysis), implementation (code development), inspection (product testing), and processing (release and launch). The cycle doesn’t end at launch; teams continuously collect feedback, identify improvement opportunities, and refine their processes.
The four phases of PDCA in software
Plan: This phase involves identifying improvement opportunities, setting objectives, and developing an actionable strategy. Software teams define project scope, gather requirements, establish timelines, and identify necessary resources. The planning stage addresses requirements analysis, coding standards, integration approaches, testing methodologies, and ongoing support needs.
Do: During implementation, teams execute the planned activities. This includes designing the software architecture, writing code, and conducting initial testing. The focus is on implementing the plan in a controlled manner, often starting with small-scale pilot programs to test feasibility before full deployment.
Check: Teams evaluate results against predetermined metrics and expectations. This assessment phase involves comparing actual outcomes with planned objectives, measuring progress, and identifying deviations. The goal is to gather data and insights about what worked and what needs adjustment.
Act: Based on insights from the Check phase, teams make necessary adjustments. If results meet expectations, successful changes are standardized and integrated into regular processes. If not, the team refines the approach and continues the cycle with improved strategies.
Design and development planning requirements
Effective design and development under ISO 9001 begins with comprehensive planning. The complexity of the design stages determines the level of planning needed, but all projects must consider design stages, inputs, controls, outputs, and change management procedures.
Planning may take various forms, from formal documented plans to structured meetings and periodic reports. The key is ensuring all planning elements are addressed and necessary information is gathered. Organizations with high dependency on design outputs typically require more detailed planning and stricter controls at each stage to ensure customer requirements are met.
Capturing design inputs
Design inputs form the foundation of any software development project. These inputs include functional specifications, performance requirements, statutory and regulatory requirements, and information from previous similar designs. Organizations must determine and record all inputs needed for design and development processes, ensuring they are clear, complete, and free from contradictions.
For software projects, design inputs might include customer contracts, technical specifications, user stories, industry standards, security requirements, and accessibility guidelines. These inputs must be documented and any discrepancies resolved before proceeding with development. The inputs should address functionality, performance, safety, maintainability, and regulatory compliance.
Design outputs and documentation
Design outputs represent the tangible results of the development process. In software organizations, these typically include source code, technical specifications, user documentation, API documentation, and test cases. The outputs must meet input requirements, provide appropriate information for subsequent processes, and include acceptance criteria where applicable.
All design and development outputs must be retained and controlled. This ensures traceability from requirements through to final implementation and enables effective change management throughout the product lifecycle.
Verification methods in software development
Verification ensures that software is built correctly according to specifications. This static testing process focuses on checking that each development phase’s outputs correctly implement the inputs from the previous phase. Verification answers the question: “Are we building the product right?”
Common verification methods include code reviews, design inspections, walkthroughs, and static code analysis. Teams systematically examine software design artifacts to verify logical correctness and alignment with requirements. Unit testing verifies individual functions work as expected in isolation, while integration testing checks how different modules interact.
The verification process is ongoing throughout development, starting early in the project lifecycle and continuing through each development stage. This early detection of issues significantly reduces the cost and effort required for corrections.
Validation methods in software development
While verification checks if software is built correctly, validation ensures the right product is being built. Validation asks “Are we building the right product?” and focuses on usefulness and fitness for purpose. This dynamic testing process occurs later in the development cycle and involves executing the software in realistic scenarios.
Validation techniques include functional testing, system testing, user acceptance testing, and performance testing. These methods ensure the software meets user needs and operates correctly in the intended environment. The combination of verification and validation is essential to ensure software products are robust, function correctly, and are secure before release.
Validation often involves end-users, clients, and stakeholders providing feedback on whether the software actually solves their problems and meets expectations. This external validation is crucial for confirming the software fulfills its intended purpose.
Configuration management’s critical role
Configuration management controls design changes and maintains consistency across requirements, design, and code. This systematic approach tracks, governs, and manages changes to software systems, minimizing errors and enhancing quality and reliability.
Key configuration management tasks include identifying configuration items (code, test cases, documentation), mapping dependencies, establishing baselines, implementing version control, and controlling changes and releases. Configuration management provides a basis for managing multi-user collaboration and accommodating changes throughout the development lifecycle.
Modern configuration management systems use tools like Git, SVN, or dedicated platforms to automate tracking and control. These systems provide detailed audit trails, enable rollback capabilities, and ensure all changes are documented and approved before implementation. Without effective configuration management, organizations risk versioning conflicts, code overwrites, and inconsistencies that can derail projects.
Design reviews, verification, and validation
ISO 9001 requires that design and development activities undergo review, verification, and validation, though these can be conducted separately or in combination as appropriate. Reviews assess progress, evaluate costs, and identify problems. Verification confirms outputs meet input requirements through simulations, testing, and document reviews. Validation ensures products are suitable for their intended use through end-user testing and capability studies.
Issues identified during any of these processes must be resolved before proceeding to production. This iterative review process ensures quality is built into the product rather than inspected in later.
Managing design changes
Change management is crucial for maintaining software quality. All design changes, whether to inputs or outputs, must follow a controlled procedure. This includes documenting change requirements, evaluating impacts on processes, resources, and schedules, obtaining proper authorization, and implementing preventive actions to avoid negative impacts.
The change control process ensures that even minor modifications are assessed for their potential ripple effects across the system. Organizations must retain documented information on all design changes to maintain traceability and support future decision-making.
What do you think? How might implementing a structured PDCA approach transform your organization’s software development process? What challenges do you anticipate in balancing rigorous verification and validation with the need for rapid delivery?
References
- https://www.softwaretestingmaterial.com/pdca-cycle/
- https://www.larksuite.com/en_us/topics/project-management-methodologies-for-functional-teams/plan-do-check-act-pdca-for-software-development-teams
- https://www.geeksforgeeks.org/software-engineering/overview-of-pdca-cycle/
- https://resources.iso-templates.com/blog/iso-9001-clause-8.3-design-and-development-explained
- https://www.compliancequest.com/cq-guide/iso-guidance-for-product-design-development/
- https://www.geeksforgeeks.org/software-engineering/software-engineering-verification-and-validation/
- https://www.browserstack.com/guide/verification-and-validation-in-testing
- https://fullscale.io/blog/software-validation-vs-verification/
- https://www.sqs.es/software-verification-and-validation/?lang=en
- https://www.ninjaone.com/blog/software-configuration-management-overview/
- https://budibase.com/resources/itil-processes/configuration-management/software-configuration-management/
Leave a Reply