CBE Nexus · Undergraduate Information Systems · Chapter 16
Capstone Systems Project and Industry Practice
Integrating systems analysis, design, implementation, testing, evaluation, governance and professional practice in a substantial undergraduate project.
By the end of this chapter, learners should be able to select and justify a feasible project; analyse stakeholder needs; define traceable requirements; design an appropriate architecture; implement or configure a solution; manage scope, schedule, risk and quality; conduct ethical testing and evaluation; document and demonstrate the work; and prepare a professional handover.
Study approach: Treat the chapter as a project lifecycle guide. Apply each section to one defined problem and maintain a portfolio of requirements, diagrams, decisions, tests, evidence and reflections.
Academic and operational caution: Obtain institutional approvals before collecting personal data, testing live systems or deploying software for real users. A classroom prototype is not automatically authorised for production use.
Capstone lifecycle
PROBLEM DISCOVERY AND TOPIC SELECTION
|
v
FEASIBILITY + BUSINESS CASE
|
v
STAKEHOLDERS + REQUIREMENTS
|
v
ANALYSIS + DESIGN
|
v
ITERATIVE BUILD / CONFIGURATION
|
v
TESTING + USER VALIDATION
|
v
EVALUATION + DOCUMENTATION
|
v
DEMONSTRATION + HANDOVER
|
v
REFLECTION / FUTURE WORK
Figure 16.1: A capstone lifecycle has review gates and feedback loops rather than a single uninterrupted coding phase.
1. Purpose and scope of the capstone systems project
A capstone systems project is a substantial, supervised undertaking in which students integrate knowledge from systems analysis, software engineering, databases, networks, cybersecurity, project management, human-computer interaction, governance and professional communication. It is not merely a coding assignment. It demonstrates the ability to understand a real problem, justify a solution, build or configure an appropriate artefact, evaluate outcomes and communicate evidence to technical and non-technical audiences.
The project should address a meaningful information systems need in a defined context. Examples include improving a clinic appointment process, building a stock visibility dashboard, redesigning a university service portal, automating document workflows or evaluating a cloud migration. The project may produce software, an architecture, a data product, a process redesign, a security improvement or a rigorous evaluation of an existing system.
A strong capstone has a traceable line from problem evidence to requirements, design decisions, implementation, testing and evaluation. Each major deliverable should answer a question: what need does it address, which stakeholder validated it, how was it implemented, and what evidence demonstrates that it works? Features that cannot be linked to a need should be reconsidered.
Project scope must be achievable within the academic calendar, available skills, budget, access and supervision. A narrow, well-evaluated system is usually stronger than an ambitious platform with incomplete functions. Students should agree exclusions, assumptions, dependencies and acceptance criteria early, then manage changes through a documented process.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
2. Selecting a project topic and identifying a real problem
Topic selection should begin with an observable problem rather than a fashionable technology. Students can identify opportunities through workplace experience, community needs, institutional service gaps, public datasets, stakeholder interviews or literature gaps. A problem should have a clear owner or affected group and consequences that can be investigated.
Assess candidate topics against relevance, feasibility, originality, access to users and data, ethical risk, technical complexity, cost and time. A weighted decision matrix can compare options, but weights should reflect project priorities. A topic requiring confidential data or unavailable integrations may be unsuitable even if it appears technically exciting.
A problem statement should describe the current situation, evidence of the difficulty, affected stakeholders, consequences and the gap the project will address. Avoid assuming that an app, blockchain or artificial intelligence is necessarily the answer. Compare process, policy, training, configuration, procurement and software alternatives before selecting an intervention.
Validate the problem with stakeholders and a supervisor. Ask users to describe tasks, workarounds, errors, delays and desired outcomes. Record evidence without exposing sensitive information. The final topic should be specific enough to guide requirements and evaluation, yet broad enough to support an academically meaningful contribution.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
3. Feasibility study and project justification
A feasibility study tests whether a proposed project is practical and worthwhile. Technical feasibility considers skills, infrastructure, integration, performance and maintainability. Economic feasibility compares costs and expected benefits. Operational feasibility examines user readiness, process fit and support. Schedule feasibility assesses whether critical work can be completed in the available period.
Legal and ethical feasibility covers privacy, intellectual property, licensing, accessibility, safety and regulatory requirements. Organisational feasibility considers sponsorship, decision rights, data ownership and the capacity to adopt the result. A project can be technically possible but unacceptable because it creates disproportionate risk or lacks an authorised data owner.
Cost estimates should include development or configuration, hosting, devices, connectivity, training, support, security, backup, migration and ongoing maintenance. Benefits may include reduced processing time, fewer errors, improved access, stronger control or better decisions. Intangible benefits should be described carefully rather than converted into unsupported monetary claims.
A business case records the problem, options, recommended approach, assumptions, costs, benefits, risks, dependencies and success measures. It should include a do-nothing baseline and explain why the selected option is preferable. Feasibility is not a one-time formality; material changes in scope, access or cost should trigger reassessment.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
4. Stakeholder analysis and project governance
Stakeholders include sponsors, end users, administrators, customers, suppliers, regulators, support staff, data subjects and people indirectly affected by the system. Their interests may differ. A sponsor may value cost and delivery speed, while a user values accessibility and task simplicity; security staff may prioritise assurance and auditability.
Stakeholder analysis identifies influence, interest, impact, expertise and potential concerns. A power-interest map can guide engagement, but low-power groups should not be ignored when they bear significant consequences. Students should document who was consulted, whose views were not available and how conflicting requirements were resolved.
Project governance establishes accountability, approvals, escalation and decision-making. A small capstone may use a supervisor, project owner and student team, while a larger project may require a steering group, technical lead, data owner and security adviser. A RACI matrix clarifies who is responsible, accountable, consulted and informed for key deliverables.
Governance should specify approval gates for scope, data access, architecture, security, testing, deployment and final acceptance. Meeting notes should record decisions, actions, owners and due dates. Students must not imply that a prototype has institutional approval or production status when it has only been demonstrated in an academic environment.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
5. Requirements engineering and traceability
Requirements describe capabilities, constraints and qualities that a solution must satisfy. Functional requirements state what the system does, such as register a user, approve a request or generate a report. Non-functional requirements describe qualities such as security, usability, performance, availability, accessibility, scalability and maintainability.
Elicit requirements through interviews, observation, workshops, document analysis, surveys, interface inspection and analysis of existing data. Ask users to demonstrate real tasks rather than only describe ideal processes. Resolve ambiguous words such as fast, secure and user-friendly by defining measurable acceptance criteria.
Prioritise requirements using methods such as MoSCoW or value-risk analysis. A minimum viable product should deliver a coherent, usable core workflow rather than a collection of disconnected screens. Requirements should be uniquely identified, testable and linked to stakeholder needs, design elements and verification evidence.
A traceability matrix connects each requirement to its source, implementation component, test case and result. This helps identify unimplemented requirements, unnecessary features and tests that lack a requirement. Changes should be logged with rationale, impact, approval and revised acceptance criteria.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
6. Systems analysis and process modelling
Systems analysis examines the current environment, processes, information flows, actors, rules and pain points before defining a target state. The as-is model captures how work actually occurs, including informal workarounds. The to-be model shows the intended process and the changes required to achieve it.
Process models may use flowcharts, BPMN, activity diagrams, use cases, data-flow diagrams or value-stream maps. Select notation that suits the audience and purpose. Models should show triggers, decisions, responsibilities, exceptions and handoffs. A diagram without a clear legend or boundary can create more confusion than it resolves.
Data analysis identifies entities, attributes, relationships, ownership, quality problems and retention needs. Students should distinguish operational data from analytical data and identify authoritative sources. Duplicate entry, inconsistent identifiers and missing validation often cause errors that a new interface alone cannot solve.
Gap analysis compares current and desired capabilities. It should identify process changes, data migration, integrations, training, policy updates and controls. The target design should simplify work where possible, not merely automate every existing inefficiency.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
7. Solution architecture and design rationale
Architecture describes the major components of a system, their responsibilities, interfaces, data flows, deployment environment and quality attributes. A context diagram shows external actors and systems; a component diagram shows internal responsibilities; and a deployment view identifies runtime nodes and connections. The level of detail should match the project's complexity.
Architecture choices involve trade-offs. A monolith may be easier to develop and deploy for a small project, while modular services may support independent scaling but introduce operational complexity. A relational database may suit structured transactions; a document store may suit flexible records; and managed cloud services may reduce infrastructure work while increasing dependency on a provider.
Design decisions should be recorded with context, alternatives, decision, consequences and review conditions. Examples include authentication method, data storage, API style, hosting region, backup strategy and integration approach. Decisions should address security, privacy, accessibility, reliability and maintainability from the beginning.
Architecture should be proportionate. Students should avoid adopting microservices, machine learning or distributed ledgers merely to appear advanced. The best architecture is one that satisfies verified requirements with acceptable complexity, cost and risk, and that the team can explain, test and maintain.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
8. User experience, interface and accessibility
User experience includes the perceptions and outcomes arising before, during and after interaction with a system. Usability concerns effectiveness, efficiency and satisfaction in a specified context. Interface design should follow real tasks, user capabilities, language, device constraints and environmental conditions rather than the developer's preferences.
Create user journeys, task flows, low-fidelity sketches and interactive prototypes before committing to implementation. Test navigation labels, feedback, error recovery, form validation and content clarity. A user should understand what happened after an action, what remains to be done and how to recover from a mistake.
Accessibility should be integrated into design and testing. Consider keyboard navigation, focus order, semantic headings, alternative text, captions, contrast, scalable text, clear labels and screen-reader behaviour. Accessibility is not only a compliance concern; it improves usability for people using different devices, languages and circumstances.
Conduct usability tests with representative participants and realistic tasks. Record completion, time, errors, assistance and participant comments. Obtain consent and avoid collecting unnecessary personal information. Findings should lead to prioritised changes, followed by retesting of critical tasks.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
9. Database design, data integrity and migration
Database design begins with a conceptual model of entities and relationships, followed by logical and physical design. Primary keys uniquely identify records; foreign keys preserve relationships; constraints enforce rules; and normalisation reduces avoidable redundancy and update anomalies. Denormalisation may be justified for performance when consistency is managed.
Data dictionaries define field names, meanings, types, allowed values, nullability, ownership and sensitivity. Validation should occur at appropriate layers, not only in the browser. Transactions should preserve consistency when multiple operations must succeed or fail together. Access should follow least privilege and separate administrative roles.
Migration planning identifies source systems, mappings, transformations, duplicate handling, cleansing, reconciliation and rollback. A test migration should measure record counts, rejected rows, referential integrity and business totals. Data owners should approve mapping rules and resolve ambiguous records before final transfer.
Protect production and personal data. Use synthetic or de-identified datasets for development wherever possible. Migration scripts should be versioned, reviewed and tested. Backups must be restorable, and the project should document retention, deletion and export procedures.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
10. Application development and integration
Implementation translates approved design into working components. Development practices include modular structure, readable naming, error handling, input validation, logging, dependency management and code review. Teams should use a consistent style and agree how work is divided to reduce integration conflicts.
APIs define contracts between systems, including endpoints, methods, payload schemas, authentication, error codes, rate limits and versioning. Integration testing should verify both successful and failed exchanges. Retries, timeouts, idempotency and duplicate messages matter when networks or external services are unreliable.
Third-party libraries and services accelerate development but create supply-chain and continuity risks. Teams should check licensing, maintenance, known vulnerabilities, data handling, support and exit options. Secrets such as API keys must not be embedded in public client code or committed to repositories.
Continuous integration can run automated tests and quality checks when changes are committed. Deployment pipelines should separate development, test and production environments, protect credentials and require appropriate approval. For an academic prototype, deployment should use a safe test environment unless formal production authorisation exists.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
11. Cybersecurity and privacy by design
Security requirements should be derived from assets, threats, vulnerabilities, impact and risk appetite. A threat model identifies trust boundaries, entry points, actors, data flows and likely abuse cases. Controls should be proportionate to the sensitivity and importance of the system.
Core controls include strong authentication, role-based authorisation, least privilege, secure session handling, encryption, input validation, dependency updates, logging, backups and incident procedures. Administrative functions should be separated from ordinary user functions, and sensitive actions should be auditable.
Privacy by design limits collection to what is necessary, explains purposes, restricts access, defines retention and supports appropriate rights and requests. A privacy impact assessment may be required where processing is likely to create high risks. Students should not use real personal data without a lawful basis and authorised safeguards.
Security testing may include code review, dependency scanning, configuration review, access-control tests and authorised vulnerability assessment. Testing must be limited to systems for which permission has been granted. Findings should be prioritised by severity, exploitability and impact, then retested after remediation.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
12. Project management, scheduling and estimation
Project management coordinates scope, schedule, cost, quality, resources, communication, risk and procurement. A work breakdown structure decomposes deliverables into manageable work packages. Each package should have an owner, estimated effort, dependencies and a definition of done.
Estimation can use expert judgement, analogous projects, decomposition or story points. Estimates should state assumptions and uncertainty. A schedule should include discovery, design, implementation, testing, documentation, review and contingency. Students should avoid allocating all available time to coding and leaving no period for evaluation.
Critical path analysis identifies the longest dependency path through a schedule. If a critical activity slips, the completion date may move unless the team changes resources or sequencing. A simple milestone plan can be sufficient for a small capstone, provided dependencies and review dates are visible.
Track progress using completed deliverables and tested outcomes rather than hours spent or lines of code. Regular reviews should surface blockers early. Scope changes should be assessed for effect on quality, risk and submission. A change that adds features but removes testing time may reduce overall project value.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
13. Agile, iterative and hybrid delivery
Agile approaches deliver work in small increments, use frequent feedback and adapt plans as learning emerges. Scrum organises work through roles, events and artefacts such as a product backlog and sprint increment. Kanban visualises flow and limits work in progress. A capstone can adopt selected practices without claiming full framework compliance.
User stories describe a capability from a stakeholder perspective and should have acceptance criteria. Backlog items need clear priority and manageable size. Sprint planning should consider team capacity and dependencies; reviews demonstrate working increments; retrospectives identify improvements to collaboration and process.
Agile does not mean no documentation, no design or no governance. Security, privacy, architecture and data migration require deliberate attention. Critical decisions and evidence should be documented continuously rather than reconstructed at the end. Definition of done should include testing, review and documentation appropriate to the work.
Hybrid delivery may combine upfront approvals and architecture with iterative development. This is useful where a project has fixed academic milestones, external approvals or procurement dependencies. The team should explain which decisions are fixed, which can evolve and how changes are controlled.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
14. Risk, issue and dependency management
A risk is an uncertain event that may affect objectives; an issue is a problem that has already occurred. A dependency is an external or internal condition needed for progress. A risk register records description, cause, consequence, likelihood, impact, owner, response and review date.
Qualitative risk scoring can use likelihood and impact scales, but scores should not create false precision. High-impact risks such as data exposure, loss of a critical supervisor, unavailable integration or failed migration need explicit mitigation and contingency. Residual risk remains after controls and should be accepted by an authorised person.
Responses include avoid, reduce, transfer or accept. Mitigation actions should have owners and deadlines. Contingency plans describe what the team will do if a risk materialises. For example, if an external API becomes unavailable, a documented mock service may allow development to continue without pretending the integration has been verified.
Risk reviews should occur at milestones and after material changes. Escalate risks outside the student's authority, especially those involving personal data, safety, contracts or production infrastructure. A risk register is useful only when it informs decisions and actions.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
15. Quality assurance, verification and validation
Verification asks whether the product has been built according to specification; validation asks whether it solves the intended problem for users. Quality assurance focuses on processes that prevent defects, while quality control inspects outputs to identify defects. Both are needed for a credible capstone.
Quality planning defines standards, review points, test levels, acceptance criteria and evidence. Static checks, peer reviews and design inspections can detect issues before execution. Test data should cover normal, boundary, invalid and exceptional conditions. Requirements traceability ensures important functions receive appropriate tests.
Validation should involve representative users and realistic tasks. A feature may pass unit tests but fail because labels are confusing or a process does not match organisational practice. Feedback should be recorded, prioritised and linked to design changes. The team should distinguish user preference from mandatory legal, security or business requirements.
Quality metrics may include defect density, test coverage, task success, response time, availability, data reconciliation and user satisfaction. Metrics require definitions and context. High code coverage does not prove that tests are meaningful, and high satisfaction from a tiny convenience sample does not establish broad acceptance.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
16. Software testing strategy and test design
Unit testing checks small components; integration testing checks interactions; system testing checks the complete solution; acceptance testing assesses whether agreed needs are met. Regression testing checks that changes have not broken existing behaviour. Security, performance, accessibility and recovery tests address quality attributes beyond basic functionality.
A test case includes identifier, requirement, preconditions, steps, input, expected result, actual result and status. Equivalence partitioning groups inputs expected to behave similarly; boundary-value analysis tests edges; decision tables test combinations of rules; and state-transition testing checks behaviour across states.
Test environments should resemble the intended deployment context where feasible. Record configuration, browser or device, versions, test data and known differences. Defects should include steps to reproduce, expected and actual behaviour, severity, evidence and owner. Retesting verifies the fix; regression testing checks nearby functions.
Testing should include negative paths and misuse cases. Examples include unauthorised access, invalid files, duplicate submissions, interrupted connections, expired sessions, malformed data and unavailable services. A project report should disclose untested areas and avoid claims of complete security or reliability based on limited tests.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
17. Performance, reliability and operational readiness
Performance concerns response time, throughput, resource use and behaviour under load. Define representative workloads and service expectations before testing. Measure median and tail latency, error rates and resource consumption rather than reporting only a best-case response. A system that is fast for one user may degrade under concurrent use.
Reliability concerns the ability to perform correctly over time. Availability is the proportion of time a service is usable under a defined measurement method. Recovery objectives describe acceptable restoration time and data loss. Backups, monitoring, alerting, redundancy and tested procedures support resilience.
Operational readiness includes deployment instructions, configuration, support ownership, logging, monitoring, backup, restore, access review, incident escalation and user guidance. A project should document what happens when a service fails and who is responsible for responding.
Observability combines logs, metrics and traces to help understand system behaviour. Logs should avoid exposing secrets and unnecessary personal information. Alerts should be actionable and tested. A prototype may have limited production monitoring, but limitations must be stated and a realistic handover plan supplied.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
18. Evaluation design and measuring project outcomes
Evaluation determines whether the solution meets its objectives and produces useful outcomes. Define evaluation questions and indicators before testing. A logic model can connect inputs and activities to outputs, short-term outcomes and longer-term impact. Not every benefit can be attributed to a prototype within a short academic period.
Technical evaluation may measure correctness, performance, security controls, data quality and reliability. User evaluation may measure task success, time, errors, accessibility and satisfaction. Organisational evaluation may examine process cycle time, rework, service reach, decision quality or cost. Each indicator needs a baseline or comparison where feasible.
Pre- and post-intervention comparisons can show change but may be affected by seasonality, workload or other simultaneous changes. A control or comparison group strengthens inference when appropriate and ethical. Qualitative feedback can explain why a metric changed or why an expected benefit did not occur.
Report results honestly, including failures, uncertainty and unintended consequences. Do not invent participants, test results or performance figures. Distinguish what was demonstrated, what was measured and what is only expected after future deployment. Recommendations should follow from the evidence.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
19. Documentation, technical writing and user support
Project documentation serves different audiences. Technical documentation explains architecture, data models, interfaces, configuration, deployment and maintenance. User documentation explains tasks, roles, error recovery and support. Project documentation records scope, decisions, risks, tests, approvals and evaluation.
Documents should be versioned, dated and consistent with the implemented system. Screenshots should represent the final tested version and avoid exposing real personal data or credentials. Diagrams need titles, legends and explanatory text. A reader should be able to trace important requirements to implementation and test evidence.
User guides should use task-oriented headings and plain language. Include prerequisites, steps, expected outcomes, common errors and support routes. Training materials should reflect user roles and accessibility needs. A help feature that does not match the actual interface damages trust.
Documentation should be reviewed by someone other than its author. Check links, spelling, terminology, screenshots, version references and completeness. A handover pack should identify known limitations, dependencies, maintenance tasks, data retention and ownership after the student team leaves.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
20. Deployment, release and change control
Deployment moves a tested build into a target environment. A release plan should identify version, changes, approvals, prerequisites, migration, backup, communications, rollback and post-release checks. Academic demonstrations should be clearly separated from production releases.
Configuration should be managed through environment-specific settings and protected secrets. Avoid hard-coding credentials, debug endpoints or test accounts in production. Use least-privilege service accounts and document required variables without publishing secret values.
Change control records the request, rationale, risk, affected requirements, testing, approval and release outcome. Small projects may use a lightweight process, but changes that affect data, security, cost or stakeholder commitments need explicit review. Emergency changes should be documented retrospectively according to an agreed procedure.
After deployment, perform smoke tests, monitor logs and verify critical workflows. Rollback should be practical and tested where possible. If a migration cannot be reversed safely, a forward-recovery plan and verified backup may be needed. Communicate incidents promptly and accurately.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
21. Intellectual property, licensing and open-source compliance
Intellectual property covers rights in code, text, images, datasets, designs, inventions and other creative work. Students should understand institutional ownership policies, project agreements and third-party licence terms before reusing materials. Attribution is required even when a resource is freely accessible.
Open-source licences differ in obligations. Some permit broad reuse with attribution; others impose conditions on redistribution or derivative works. Dependencies should be inventoried, licence compatibility checked and notices preserved where required. A public repository should not contain copied proprietary code or unlicensed media.
Data rights and software rights are distinct. Permission to access a dataset does not necessarily grant permission to republish it. Personal data may be subject to additional legal obligations. Students should document dataset provenance, licence, permitted purpose and restrictions.
AI-generated code, text and media require verification and compliance with institutional rules and tool terms. Generated material may contain errors or resemble protected work. Students remain responsible for originality, attribution, security and the accuracy of submitted work.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
22. Teamwork, leadership and conflict resolution
Capstone teams need clear roles, shared objectives and transparent workload allocation. Roles may include project coordinator, analyst, developer, data lead, tester, security lead and documentation editor. Small teams may share roles, but accountability for each deliverable should remain explicit.
Team agreements should define communication channels, meeting frequency, response expectations, repository practices, decision rules and conflict escalation. Work should be visible through a shared backlog and version control. Regular integration reduces the risk that separate components fail to work together near submission.
Conflict often arises from unclear expectations, unequal workload, different technical preferences or missed commitments. Address issues early using evidence and respectful discussion. Separate disagreement about ideas from judgement about people. If a team cannot resolve a matter, use the agreed supervisor or programme escalation route.
Peer assessment should consider contribution quality, reliability, collaboration, initiative and support, not only visible coding volume. Keep records of decisions and contributions without turning project management into surveillance. Leadership includes enabling others, communicating risks and accepting responsibility for team outcomes.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
23. Industry engagement, internships and workplace learning
Industry engagement can provide realistic problems, mentoring, user access, data and feedback. Agreements should clarify project scope, confidentiality, intellectual property, permitted data use, supervision and whether the deliverable is a prototype or operational product. Students should not promise delivery beyond academic authority.
Workplace learning requires professional conduct: punctuality, respectful communication, safe handling of information, accurate reporting and adherence to organisational policies. Students should observe access controls and never use another person's account or copy restricted data for convenience.
Industry mentors can explain operational constraints, but academic supervisors retain responsibility for academic standards and assessment. Students should record feedback, distinguish stakeholder preference from research evidence and document any conflict between commercial goals and ethical or academic obligations.
Reflective logs help connect workplace experience to theory. A useful reflection identifies a situation, the action taken, the reasoning, the outcome, what could be improved and how learning will influence future practice. Confidential details should be anonymised or excluded.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
24. Project reporting, demonstration and viva preparation
A capstone report should tell a coherent story from problem to evidence-based conclusion. Common sections include abstract, introduction, literature or background, methodology, requirements, design, implementation, testing, evaluation, discussion, conclusion, recommendations, references and appendices. Follow the programme's required format and word limits.
The abstract should summarise the problem, approach, artefact, evaluation and main findings. The introduction establishes context and objectives. The methodology explains how decisions and evidence were produced. The implementation chapter should describe important design choices rather than reproducing large blocks of source code.
A demonstration should be planned around realistic user tasks and verified data. Prepare a stable environment, test accounts, backup recording or screenshots where permitted, and a fallback if connectivity fails. Demonstrate both successful workflows and how the system handles errors. Do not imply that simulated data or mock integrations are real production services.
Viva preparation should include the problem rationale, requirements, architecture, alternatives, security, testing, limitations, personal contribution and future work. Students should be able to explain why choices were made, what evidence supports claims and what they would change. Honest acknowledgement of limitations is stronger than defensive exaggeration.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
25. Research ethics and human-centred project practice
Projects involving people, interviews, observation, surveys, usability tests or personal data may require ethics review and informed consent. Students should check institutional requirements before recruitment or collection. Approval cannot be assumed because the project is educational or because participants are colleagues or friends.
Participants should understand purpose, activities, foreseeable risks, data use, confidentiality limits and withdrawal arrangements. Recruitment should avoid pressure, especially where students have authority over participants or where employees may fear consequences. Provide accessible information and appropriate accommodations.
Minimise personal data and use synthetic records for development. Separate identifiers from research responses, restrict access and apply retention and deletion rules. A small dataset or disguised name may still identify a person through context. Avoid screenshots, logs or demonstration accounts that reveal private information.
Human-centred design includes considering exclusion, accessibility, safety, fairness and the distribution of benefits and burdens. A system can be technically successful yet harm users through surveillance, discriminatory rules or inaccessible processes. Ethical review should continue as features and project context change.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
26. Sustainability and responsible technology choices
Sustainable information systems consider environmental, economic and social effects across acquisition, development, operation and disposal. Energy consumption, device lifetimes, data-centre impacts, e-waste, repairability and connectivity demands may all matter. Cloud migration does not automatically make a system sustainable; workload and provider practices influence impact.
Design choices can reduce unnecessary processing, storage and data duplication. Efficient queries, caching, right-sized resources, lifecycle policies and accessible low-bandwidth interfaces may improve both cost and environmental performance. Reuse and repair can extend hardware life where security and support permit.
Social sustainability includes accessibility, inclusion, fair work, community impact and long-term service continuity. Economic sustainability considers recurring licences, support, skills and vendor dependence. A solution that cannot be maintained after the project ends may create operational debt.
Students should state which sustainability dimensions they assessed and what evidence was available. Avoid unsupported claims such as carbon-neutral or universally inclusive. Identify trade-offs and recommend practical improvements, such as measuring energy use, reducing storage retention or supporting low-connectivity users.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
27. Emerging technologies and responsible adoption
Emerging technologies can create new capabilities but also new dependencies and risks. Artificial intelligence, edge computing, Internet of Things, extended reality, digital identity, distributed ledgers, robotics and quantum technologies should be assessed against a real use case. A technology is not a solution merely because it is novel.
Technology assessment should consider maturity, interoperability, security, privacy, explainability, accessibility, cost, skills, regulation, vendor support and exit options. Pilot projects should have defined success criteria and stop conditions. A proof of concept demonstrates limited feasibility; it does not establish production readiness or business value.
AI-enabled systems require attention to data quality, bias, human oversight, error handling, provenance and accountability. Users should understand when automated outputs influence decisions. High-impact use cases need appropriate validation, monitoring, appeal routes and human review. Generative output should be checked before it is used as authoritative information.
IoT and edge systems expand the attack surface through devices, firmware, physical access and network connectivity. Secure provisioning, updates, identity, segmentation and lifecycle support are essential. Distributed ledgers may offer shared tamper-evident records in some settings, but governance, privacy, throughput and correction mechanisms remain important.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
28. Handover, maintenance and post-project review
A project handover transfers knowledge, artefacts and responsibilities to an owner or support team. It should include source code where permitted, architecture, deployment steps, configuration guidance, data dictionary, test evidence, user documentation, known defects, licences and contact or escalation information.
Maintenance includes corrective work to fix defects, adaptive work to respond to environmental changes, perfective work to improve capability and preventive work to reduce future problems. A project should identify likely maintenance needs and the skills or costs required. A system without an owner or update plan may become unsafe or unusable.
Post-project review compares planned and actual outcomes, schedule, cost, quality, stakeholder experience and lessons. It should identify what worked, what did not, why assumptions changed and which practices should be repeated. The review should include unintended consequences and unresolved risks.
Future work should be prioritised by user value, risk reduction, feasibility and evidence. Avoid listing fashionable features without a rationale. A clear roadmap identifies dependencies, owners, estimated effort and acceptance criteria, while distinguishing essential remediation from optional enhancement.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
29. Capstone assessment, academic standards and reflective learning
Assessment should evaluate the quality of problem definition, literature and rationale, requirements, design, implementation, testing, evaluation, ethics, documentation, presentation and individual contribution. Rubrics should be understood early. A polished interface cannot compensate for missing evidence, and a technically complex system cannot excuse unsafe data practices.
Academic standards require authentic work, accurate attribution, honest reporting and compliance with collaboration rules. Students should disclose use of external code, datasets, templates and AI tools according to institutional requirements. They should retain evidence of development and be able to explain submitted work.
Reflection examines learning and professional growth. Students can compare initial assumptions with findings, identify skills developed, assess teamwork and describe how feedback changed the solution. Reflection should be specific and evidence-based rather than a generic statement that the project was successful.
The capstone is a transition from guided study to professional practice. Its lasting value lies not only in the artefact but in the ability to frame problems, work responsibly with stakeholders, make reasoned technical decisions, test claims and communicate limitations.
Capstone practice: Record the decision, the evidence supporting it, the stakeholder affected, the test that will verify it and the limitation that remains. This habit creates a defensible project trail and makes the final report easier to write.
Applied capstone case studies
Community clinic appointment and queue management
Context
A community clinic records appointments in notebooks and patients often wait without knowing whether a clinician is available. The project team proposes a web-based appointment and queue system.
Analysis and requirements
The team maps the current workflow, interviews authorised staff and patients, and identifies constraints such as shared devices, intermittent connectivity and confidentiality. It defines a minimum scope: appointment requests, staff confirmation, queue status and aggregate reporting. It avoids storing unnecessary clinical details.
Design and verification
The design uses role-based access, minimal patient identifiers, secure sessions and audit logs. Testing uses synthetic patient records. Usability sessions include participants with different literacy and device experience. Offline contingencies and staff override procedures are documented.
Evaluation and handover
Evaluation measures booking completion, duplicate appointments, queue information accuracy and user task success against a baseline where feasible. The report identifies limitations and recommends a controlled pilot, staff training and formal privacy approval before any real deployment.
University resource inventory and asset accountability
Context
A university department uses spreadsheets to track laptops, projectors and laboratory equipment. Items are frequently moved without updated records, and annual reconciliation is time-consuming.
Analysis and requirements
The team consults storekeepers, technicians, finance and departmental administrators. It defines asset registration, assignment, transfer, maintenance status and audit reporting as core functions. It models unique asset identifiers and role-specific workflows.
Design and verification
The database enforces identifier uniqueness and records a timestamped movement history. The team tests concurrent updates, invalid transfers, permissions and export reports. Migration is trialled with a copy of cleansed data and reconciled against source totals.
Evaluation and handover
Evaluation compares reconciliation time, record completeness and discrepancy rates. The team documents data ownership, backup, maintenance and training. The system is handed over as a tested prototype unless the university authorises production use.
Small retailer cloud migration and point-of-sale integration
Context
A retailer wants to move sales and inventory records from a local computer to a cloud platform and connect a point-of-sale terminal. The vendor promises seamless migration and unlimited availability.
Analysis and requirements
The capstone assesses connectivity, data volume, integration interfaces, licensing, payment-data boundaries, staff readiness and supplier exit options. It compares cloud and local alternatives and develops a migration business case with explicit assumptions.
Design and verification
A staged test migration maps products, stock balances and customer records, while avoiding unnecessary personal data. Reconciliation checks record counts and inventory totals. Integration tests cover timeouts, duplicate messages and recovery from interrupted synchronisation.
Evaluation and handover
The evaluation reports migration accuracy, transaction latency and recovery behaviour in the test environment. The project recommends a phased pilot, contractual review, tested backup and rollback, staff training and a supplier exit plan before business-critical cutover.
Accessible student support portal
Context
Students report difficulty finding support services, especially on mobile devices and with assistive technologies. A proposed portal will centralise service information and requests.
Analysis and requirements
The team conducts stakeholder mapping and accessible user research, including students with different access needs. It defines clear navigation, plain-language content, keyboard access, status tracking and privacy requirements. The scope excludes sensitive counselling records.
Design and verification
Prototype tests examine focus order, labels, contrast, screen-reader announcements, responsive layout and error recovery. Request data is minimised and role access is tested. Participants receive accessible study information and consent is obtained before usability sessions.
Evaluation and handover
Evaluation combines task success, error counts, time and qualitative feedback. Findings are prioritised and retested. The team recommends content ownership, accessibility regression checks and a support process so the portal remains current after handover.
Requirements-to-evidence traceability
STAKEHOLDER NEED
|
v
REQUIREMENT ID + ACCEPTANCE CRITERION
|
v
DESIGN COMPONENT / PROCESS
|
v
IMPLEMENTED FEATURE
|
v
TEST CASE + OBSERVED RESULT
|
v
EVALUATION FINDING + DECISION
Figure 16.2: Traceability makes it possible to demonstrate how a stakeholder need was addressed and verified.
University examination questions and model answers
These questions assess project reasoning, calculations, technical judgement and professional practice. For extended responses, state assumptions, justify decisions and discuss limitations.
1. Explain the purpose of a capstone systems project.
Model answer: It integrates technical, analytical, managerial and professional learning in a substantial project. Students identify a real problem, justify a solution, develop or configure an artefact, evaluate it and communicate evidence and limitations.
2. Distinguish a project topic from a problem statement.
Model answer: A topic names the general area of work. A problem statement explains the current difficulty, evidence, affected stakeholders, consequences and the gap the project will address.
3. Identify five dimensions of feasibility.
Model answer: Technical, economic, operational, schedule, and legal/ethical feasibility are common dimensions. Organisational readiness and resource availability should also be considered.
4. What is a stakeholder register used for?
Model answer: It records relevant stakeholders, their roles, interests, influence, impact, engagement needs and concerns. It helps ensure that requirements and decisions consider affected groups.
5. Differentiate functional and non-functional requirements.
Model answer: Functional requirements describe system behaviours or services. Non-functional requirements describe qualities and constraints such as security, usability, performance, availability and accessibility.
6. Explain requirements traceability.
Model answer: Traceability links each requirement to its source, design or implementation element, test case and outcome. It helps verify coverage, control changes and identify unnecessary features.
7. Compare an as-is process model with a to-be process model.
Model answer: The as-is model describes the current process as performed. The to-be model describes the intended future process and the changes required to reach it.
8. State four items that should appear in an architecture decision record.
Model answer: Context or problem, decision, alternatives considered, rationale, consequences and conditions for review are suitable contents.
9. Why should accessibility be included from the beginning of a project?
Model answer: Early integration avoids expensive redesign and helps people with different abilities, devices and contexts complete tasks. It improves usability and reduces exclusion.
10. Explain database normalisation and give one benefit.
Model answer: Normalisation organises relational data to reduce redundancy and update anomalies. It improves consistency by storing facts in appropriate relations and enforcing keys and constraints.
11. What is an API contract?
Model answer: It specifies how systems communicate, including endpoints, methods, request and response schemas, authentication, error handling, limits and versioning.
12. List five security-by-design controls for a student project.
Model answer: Least privilege, strong authentication, role-based authorisation, encryption, secure session handling, input validation, dependency updates, audit logging and tested backups are examples.
13. A project has tasks A (2 days), B (4 days after A), C (3 days after A), and D (2 days after both B and C). Calculate the project duration.
Model answer: Path A-B-D is 2+4+2 = 8 days. Path A-C-D is 2+3+2 = 7 days. The critical path is A-B-D and the minimum planned duration is 8 days, excluding contingency.
14. Differentiate a risk from an issue.
Model answer: A risk is an uncertain future event that may affect objectives. An issue is a problem that has already occurred and requires action.
15. Compare verification and validation.
Model answer: Verification checks whether the product conforms to specification; validation checks whether it meets the intended user or business need.
16. Name four levels or types of software testing.
Model answer: Unit, integration, system, acceptance and regression testing are common. Security, performance and accessibility testing address specific quality attributes.
17. A test records 42 successful tasks from 50 attempts. Calculate the task success rate.
Model answer: Task success rate = 42/50 × 100 = 84%. The report should define success and describe participants, task conditions and errors.
18. Why is a prototype not automatically production-ready?
Model answer: A prototype may lack operational security, resilience, scalability, support, data governance, accessibility assurance, monitoring, tested recovery and formal approval.
19. Explain the purpose of a change log.
Model answer: It records requested changes, reasons, impact, approvals, implementation and verification. It supports traceability and prevents uncontrolled scope changes.
20. What should a migration rehearsal verify?
Model answer: It should verify mappings, record counts, data quality, referential integrity, business totals, rejected records, performance, backup and rollback or forward-recovery procedures.
21. Distinguish a project deliverable from an outcome.
Model answer: A deliverable is a tangible output such as a tested application or report. An outcome is a resulting change, such as reduced processing time or improved access.
22. What is a usability test and name four measures.
Model answer: A usability test observes representative users completing realistic tasks. Measures include task success, time, errors, assistance required and satisfaction.
23. Why should project teams use version control?
Model answer: It records changes, supports collaboration, enables review and rollback, and helps connect source code to tested releases. Secrets and restricted data must not be committed.
24. Explain intellectual property and open-source licence compliance.
Model answer: Intellectual property protects creative and technical work. Open-source licences grant reuse under conditions that may include attribution, notices or sharing obligations. Teams must check compatibility and permitted use.
25. What should a capstone handover pack contain?
Model answer: Source and build instructions where permitted, architecture, configuration guidance, data dictionary, test evidence, user guide, known defects, licences, backup and maintenance procedures, and ownership details.
26. A service has a measured uptime of 99 hours during a 100-hour observation window. Calculate availability.
Model answer: Availability = 99/100 × 100 = 99%, assuming the measurement definition and observation window are valid.
27. Discuss two ethical risks in usability testing.
Model answer: Participants may feel pressured to take part, and recordings or screen captures may expose personal information. Voluntary consent, data minimisation, secure storage and withdrawal safeguards help reduce these risks.
28. What is the difference between a pilot and a full deployment?
Model answer: A pilot is a limited, controlled trial used to assess feasibility and outcomes. Full deployment makes the system operational for its intended population and requires broader readiness, support, governance and risk controls.
29. Why should a capstone report disclose limitations?
Model answer: Limitations show the boundaries of evidence, prevent exaggerated claims and help readers judge transferability, reliability and future work.
30. Describe the purpose of a post-project review.
Model answer: It compares planned and actual outcomes, identifies causes of success or difficulty, captures lessons, reviews unresolved risks and informs future improvement.
Project quality model
PROJECT VALUE
|
+-------------+-------------+
| | |
FIT FOR NEED TECHNICAL RESPONSIBLE
QUALITY PRACTICE
| | |
+-------------+-------------+
|
EVIDENCE + HANDOVER
|
SUSTAINABLE OUTCOME
Figure 16.3: Project quality combines fitness for purpose, technical quality, responsible conduct and sustainable ownership.
Chapter summary
A successful capstone begins with a real and evidenced problem, a feasible scope and meaningful stakeholder engagement. Requirements should be testable and traceable. Architecture, data, interface and security decisions should be justified against the project's needs and constraints. Delivery requires disciplined management of schedule, scope, risk, quality and team collaboration.
Testing and evaluation must distinguish technical correctness from user and organisational value. Ethical approval, privacy, security, intellectual property and accessibility apply throughout. A professional report, demonstration and handover should communicate what was built, what was measured, what remains uncertain and what is required for safe continuation. The capstone demonstrates not only technical skill but the judgement and accountability expected of an information systems professional.
Official Education References
Use these official organisations for curriculum guidance, examinations and further learning information.