Skip to topic
    ← Back to course topics

    Design — AQA A-Level Computer Science

    In AQA A-Level Computer Science, design represents the critical stage of the software development lifecycle where abstract requirements are transformed into precise algorithmic blueprints, data structures, interface layouts, and test plans. Mastering design enables students to decompose complex problems modularly, ensuring systems are robust, scalable, and fully verifiable prior to implementation.

    Design explained

    This statement requires you to understand that design comes before construction in the software development process.

    Read the full explanation

    Once a problem has been analysed, a developer should specify the solution on paper before writing any code. The statement gives four examples of what design involves. First, planning data structures for the data model means deciding how data will be organised, such as choosing between an array, a record or a database table. Second, designing algorithms means deciding on the step-by-step procedures that will solve each part of the problem, often written as pseudocode or flowcharts. Third, designing an appropriate modular structure means dividing the solution into named modules, each with a clear purpose, inputs and outputs. Fourth, designing the human user interface means planning screen layouts, menus, input methods and error messages before any interface is coded.

    Your focus

    1. Be aware that before constructing a solution, the solution should be designed and specified, for example planning data structures for the data model, designing algorithms, designing an appropriate modular structure for the solution and designing the human user interface.

    Which command word is this?

    Produce an algorithm, data structure, diagram, or plan using appropriate standard notations (such as pseudocode, flowcharts, or structure charts) that fully solves the stated problem specifications.

    Design exam tips

    Topic Overview

    The design phase is the architectural foundation of the systems development lifecycle (SDLC) within AQA A-Level Computer Science. It bridges the analytical requirements specification and the physical implementation, defining how a system will meet stakeholder objectives through modular decomposition, algorithm design, data modelling, and human-computer interface specifications.

    Understanding structured and object-oriented design principles is essential not only for written exam components (Paper 1 and Paper 2) but also for maximizing marks in the Non-Exam Assessment (NEA). A well-executed design guarantees that systems are maintainable, algorithms are computationally efficient, and system behaviours can be thoroughly validated using structured testing strategies.

    Key Concepts
    • →Modular Decomposition & Top-Down Design: Breaking down complex problems into smaller, manageable subroutines using structure charts, stepwise refinement, and functional abstraction.
    • →Data Structure & Algorithm Specification: Choosing appropriate data structures (e.g., 2D arrays, linked lists, dictionaries) and representing algorithm logic via standardized pseudocode and flowcharts.
    • →Interface Design: Crafting intuitive User Interfaces (UI) considering human-computer interaction (HCI) principles, input validation mechanisms, and user accessibility.
    • →Defensive Design & Test Strategies: Structuring rigorous validation checks and detailed test matrices covering normal, boundary, and erroneous data inputs to verify robustness.
    Marking Points
    • Recognises that design happens before construction begins
    • Identifies planning of data structures as part of design
    • Identifies designing algorithms as part of design
    • Identifies designing a modular structure as part of design
    • Identifies designing the human user interface as part of design
    Examiner Tips
    • 💡Name all four design activities if asked to list design tasks
    • 💡Link each design activity to the solution it will later guide
    • 💡Use the phrase 'before constructing' to show you understand the sequence of design and construction
    • 💡In algorithm design questions, clearly state parameter types and return types in your subroutine headers to gain easy technical marks.
    • 💡When asked to design a database or data storage mechanism, always specify the exact data type, length, and primary/foreign keys rather than just table names.
    • 💡Ensure every test plan design includes precise expected outcomes, including exact error messages rather than vague phrases like 'system crashes' or 'it doesn't work'.
    Common Mistakes
    • Treats coding as the first step and designs features as they are written; correct by specifying the solution before construction starts
    • Confuses data structure design with writing the code that stores the data; correct by planning the structure, such as a record with named fields, in advance
    • Omits the user interface from design and assumes it can be added at the end; correct by sketching screens and menus during design
    • Thinking design only occurs once in a rigid sequence: In iterative methodologies (such as Agile or Spiral models), design is cyclical and evolves as prototypes are evaluated.
    • Believing pseudocode must match exact programming syntax: Pseudocode must be language-independent and focus on unambiguous algorithmic logic, control structures, and variable operations rather than Python or Java syntax quirks.
    • Assuming structure charts show chronological order of execution: Structure charts depict hierarchical relationships and parameter flows between modules, not strict temporal execution sequence.
    Revision Plan
    1. 1Day 1-3: Master top-down design and structure chart conventions (modules, data couples, control flags, selection, iteration).
    2. 2Day 4-6: Practice writing formal AQA-compliant pseudocode for common problem scenarios, focusing on modularity and parameter passing.
    3. 3Day 7-9: Study test plan construction and defensive design techniques, drilling boundary value identification across various data types.
    4. 4Day 10-12: Complete past paper questions on database schema design, UI wireframes, and object-oriented class diagrams.
    Exam Question Types
    • 📋Algorithm Design Questions: Writing pseudocode or drawing system flowcharts to solve a stated computational problem (often 6 to 9 marks).
    • 📋Structure Chart Completion: Interpreting a scenario to complete missing modules, parameters, or flag arrows on an uncompleted diagram.
    • 📋Test Plan Formulation: Constructing a tabular test strategy with defined test data, testing types, and expected outputs for validation routines.
    Command Word Expectations (AQA)
    Design

    Produce an algorithm, data structure, diagram, or plan using appropriate standard notations (such as pseudocode, flowcharts, or structure charts) that fully solves the stated problem specifications.

    Justify

    Provide reasoned arguments and evidence to support a design choice (such as choosing a hash table over a linear array), detailing the benefits and potential trade-offs in context.

    Explain

    Set out the purposes or mechanisms of a design element (e.g., explaining why modular design facilitates team development and unit testing) with clear cause-and-effect reasoning.

    How Students Lose Marks (Examiner Pitfalls)
    Pitfall: Confusing boundary test data with erroneous test data, or selecting incorrect values for boundary tests.
    ❌ Weak Answer (Loses Marks):For a range of 1 to 100, boundary data is 0 and 101 because they test the limits of what fails.
    Example improved answer:For an inclusive range of 1 to 100, boundary test data must test both sides of the acceptance limit: valid boundaries are 1 and 100, while invalid boundary values are 0 and 101. Normal data would be any integer from 2 to 99, and erroneous data would be non-numeric input such as 'ten' or out-of-range values like -5.
    Examiner Tip: Always explicitly define whether a range is inclusive or exclusive, and provide both the valid boundary value and the immediate invalid neighbour on either side.
    Pitfall: Misusing structure chart symbols, particularly confusing data couples with control flags, or omitting iteration/selection indicators.
    ❌ Weak Answer (Loses Marks):Drawing basic boxes connected with plain arrows, labeling everything as data passing without using correct arrow tails.
    Example improved answer:A compliant structure chart uses an arrow with an open circle tail to denote a data couple (e.g., studentID), an arrow with a solid filled circle tail to denote a control flag (e.g., EOF_flag), a diamond symbol at the module base to denote selection, and a curved loop across connecting lines to denote iteration.
    Examiner Tip: Memorise the exact British Standard/AQA standard graphical conventions for structure charts; examiners penalise plain arrows when parameter passing types are requested.
    Step-by-Step Worked Solutions

    Question: A school registration system requires an input routine to accept and validate a student's attendance percentage. The percentage must be a real number between 0.0 and 100.0 inclusive. Design a comprehensive test plan for this input routine, identifying four distinct tests. For each test, state the test type, test data, and expected outcome.

    1. 1.Step 1: Identify the validation rule and boundary conditions. The rule is 0.0 <= attendance <= 100.0. Type is real numeric.
    2. 2.Step 2: Select a Normal test case. Choose a standard value comfortably within the valid range, e.g., 85.5. Expected outcome: Data accepted.
    3. 3.Step 3: Select Boundary test cases. The lower boundary requires testing 0.0 (valid) and -0.1 (invalid). The upper boundary requires testing 100.0 (valid) and 100.1 (invalid). Select 0.0 as valid boundary and 100.1 as invalid boundary.
    4. 4.Step 4: Select an Erroneous test case. Choose a value that violates the data type entirely, e.g., 'Present' or 'N/A'. Expected outcome: Error message generated and re-entry prompted.
    5. 5.Step 5: Tabulate the selected tests systematically with explicit columns: Test Number, Test Type, Test Data, Purpose, Expected Outcome.
    Final Answer: Test 1 (Normal): Data = 74.2; Expected: Accepted. Test 2 (Valid Boundary): Data = 0.0; Expected: Accepted. Test 3 (Invalid Boundary): Data = 100.1; Expected: Rejected with error 'Percentage cannot exceed 100.0'. Test 4 (Erroneous): Data = 'absent'; Expected: Rejected with type mismatch error 'Must be numeric'.

    Question: An e-commerce application calculates shipping costs. If an order total is greater than or equal to £50, shipping is free. Otherwise, standard shipping is £4.99. If express delivery is chosen, an additional £3.50 is added regardless of order total. Write pseudocode to design an algorithm for a function CalculateShipping(orderTotal, isExpress) that returns the total shipping fee.

    1. 1.Step 1: Define the function header with parameters: CalculateShipping(orderTotal, isExpress).
    2. 2.Step 2: Initialise a local variable shippingCost to 0.0.
    3. 3.Step 3: Implement selection logic for base shipping: IF orderTotal < 50.00 THEN shippingCost = 4.99 ELSE shippingCost = 0.00 ENDIF.
    4. 4.Step 4: Implement selection logic for the express add-on: IF isExpress == TRUE THEN shippingCost = shippingCost + 3.50 ENDIF.
    5. 5.Step 5: Return the calculated shippingCost.
    Final Answer: FUNCTION CalculateShipping(orderTotal : REAL, isExpress : BOOLEAN) RETURNS REAL DECLARE shippingCost : REAL IF orderTotal < 50.00 THEN shippingCost = 4.99 ELSE shippingCost = 0.00 ENDIF IF isExpress == TRUE THEN shippingCost = shippingCost + 3.50 ENDIF RETURN shippingCost ENDFUNCTION
    Active Recall Memory Test
    What are the three essential components that must be present in every row of an AQA-compliant software test plan?
    Key Fact: Test type (normal, boundary, or erroneous), test data value, and the specific expected outcome/result.
    On a structure chart, how do you differentiate visually between a data couple and a control flag?
    Key Fact: A data couple uses an arrow with an open circular tail, whereas a control flag uses an arrow with a solid (filled) circular tail.
    Why does modular decomposition improve the maintainability of a software solution?
    Key Fact: It isolates functionality into independent subroutines, allowing individual modules to be modified, debugged, or updated without unintended side-effects on the rest of the system.
    Frequently Asked Questions
    How detailed should my pseudocode be in an AQA exam design question?
    Your pseudocode needs to be detailed enough that a programmer could translate it directly into code without ambiguity. It should explicitly demonstrate variable initialisation, clear conditional evaluations, loop parameters, and subroutine returns. You do not need language-specific syntax like semicolons or import statements, but standard constructs such as IF...THEN...ELSE, FOR, and WHILE loops must be clearly defined.
    What is the difference between top-down design and stepwise refinement?
    Top-down design is the high-level software engineering strategy of breaking a large system down into successively smaller subsystems or functional modules. Stepwise refinement is the tactical technique applied within that process, where the internal logic of each module is expressed initially in broad statements and progressively expanded into lower-level, executable algorithmic detail.
    What documentation belongs in the Design section of the AQA NEA project?
    The NEA Design section requires a comprehensive technical blueprint of your solution before coding. This includes data structure definitions, entity-relationship diagrams (ERDs) or object-oriented class diagrams, system flowcharts or structure charts, algorithm pseudocode, wireframe UI designs with navigation maps, and a thorough test matrix identifying test cases for every requirement.
    Why is defensive design important during the design phase?
    Defensive design anticipates misuse, accidental incorrect input, and hostile attacks before code is ever written. By planning input sanitisation, validation checks (e.g., range, presence, length, and format checks), and exception handling routines during design, you prevent runtime errors, protect data integrity, and ensure software stability.
    Can I use flowcharts instead of pseudocode for design questions?
    Yes, unless the question explicitly specifies pseudocode or program code. Standard ISO flowchart symbols (terminator, process, decision, input/output, and connector) must be used accurately. However, pseudocode is generally faster to write and easier to edit under exam time constraints, making it the preferred choice for most candidates.