Home › Software Engineering › Chapter 10
Learning outcomes
After studying this chapter, learners should be able to explain the core concepts, analyse a realistic engineering problem, select and justify an appropriate method, communicate a design clearly, identify risks, and verify the resulting work against explicit criteria.
Study method: Read each topic, reproduce the diagrams from memory, complete the practical activity, answer the revision questions before checking guidance, and maintain a glossary of unfamiliar technical terms.
Feedback from testing and operation returns to requirements and design; the process is iterative rather than a one-way sequence.
1. Software projects and delivery constraints
Software projects and delivery constraints is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
2. Agile values, principles and empirical control
Agile values, principles and empirical control is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
3. Scrum roles, events and artefacts
Scrum roles, events and artefacts is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
4. Kanban flow, WIP limits and service delivery
Kanban flow, WIP limits and service delivery is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
5. Requirements backlogs, user stories and refinement
Requirements backlogs, user stories and refinement is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
6. Estimation, forecasting and release planning
Estimation, forecasting and release planning is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
7. Git workflows, branching and code collaboration
Git workflows, branching and code collaboration is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
8. Continuous integration and automated pipelines
Continuous integration and automated pipelines is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
9. Continuous delivery, deployment strategies and rollback
Continuous delivery, deployment strategies and rollback is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
10. Infrastructure as code and environment management
Infrastructure as code and environment management is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
11. Monitoring, incident response and SRE practices
Monitoring, incident response and SRE practices is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
12. Retrospectives, metrics and sustainable improvement
Retrospectives, metrics and sustainable improvement is a core engineering concern because software systems must satisfy stakeholder needs while remaining understandable, testable and operable. Begin by stating the problem, the system boundary and the assumptions that shape the solution. Identify the people and services that interact with the system, the information they exchange, and the consequences of incorrect or delayed behaviour. A sound engineering decision is not simply a fashionable technology choice: it is a reasoned response to constraints, evidence and quality objectives.
In practice, document the decision before implementation. Record the alternatives considered, the advantages and limitations of each, and the reason the selected approach fits the context. Translate the decision into observable behaviour, interface contracts and acceptance criteria. Keep responsibilities cohesive, minimize unnecessary coupling, and define how errors, exceptional conditions and changes will be handled. Review the design with another developer and use a small experiment or prototype where uncertainty is high.
For a worked example, imagine a university learning portal serving students, lecturers and administrators. Trace one user task from the interface through the application logic to persistent data and operational monitoring. Identify validation points, permissions, expected responses and recovery behaviour. Then consider how the same design behaves when a user submits incomplete information, a dependency becomes unavailable, or demand rises sharply. This scenario turns abstract terminology into engineering decisions that can be inspected and tested.
Engineering check: Can another team member explain the purpose, inputs, outputs, dependencies, failure behaviour and verification method without relying on undocumented assumptions? If not, improve the specification and supporting evidence.
Traceability helps teams demonstrate that important needs have been implemented and verified.
Practical laboratory / applied project
Work in a small team to design a modest feature for a campus learning portal. Produce a one-page problem statement, stakeholder list, system context diagram, concise requirements, a design sketch, a risk register and a test plan. Implement a small demonstrator or prototype where appropriate. Use version control, record meaningful commits, request peer review and keep evidence of decisions.
Submission evidence: problem statement; assumptions; diagram; decision log; prototype or pseudocode; test cases and results; short reflection. Your assessor should be able to trace each major requirement to a design decision and a verification activity.
Assessment rubric (100 marks): problem analysis 15; technical accuracy 20; design quality 20; implementation or prototype 15; testing and evidence 15; communication and reflection 10; collaboration and version-control practice 5.
Revision questions and answer guidance
1. Define the central purpose of this chapter and distinguish it from the adjacent discipline.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
2. Explain the main concepts using a realistic software product example.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
3. Draw and label a suitable architecture, process or data-flow diagram.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
4. Compare two approaches and state the conditions under which each is appropriate.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
5. Identify assumptions that should be documented before implementation.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
6. Describe a failure mode and explain how an engineer would detect it.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
7. Propose a test or validation method for the most important requirement.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
8. Explain the security, privacy or ethical implications of the design.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
9. Interpret a small set of technical evidence such as a query plan, test result or metric.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
10. Recommend a maintainability improvement and justify its likely benefit.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
11. Describe how the design should change when scale or workload increases.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
12. Explain how version control and peer review contribute to quality.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
13. Create a concise implementation plan with measurable acceptance criteria.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
14. Evaluate a trade-off involving cost, performance, reliability or usability.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
15. Reflect on the limitations of your proposed solution and identify further investigation.
Answer guidance: Define terms precisely, use a relevant example, explain the reasoning, and state assumptions or limitations.
Revision checklist
- I can define the chapter vocabulary accurately.
- I can explain the concepts without memorising isolated phrases.
- I can draw and interpret the diagrams.
- I can apply the methods to a realistic software product.
- I can justify trade-offs and identify limitations.
- I can produce evidence that supports my engineering decisions.
Further study and academic integrity
Use current university textbooks, peer-reviewed research, official technical standards and primary product documentation to deepen this introductory framework. Check publication dates and version numbers because engineering tools and recommended practices evolve. Cite sources in the style required by your institution. Do not present generated text, code or diagrams as experimental evidence; independently verify every claim, calculation and implementation.