Back to ESP Overview
Task 3

Designing a Solution

Apply systematic problem decomposition and algorithm design to create clear, implementable solutions that can be understood by both technical teams and clients.

AO3 (Selecting techniques and resources) - 9%
Assessment Objective
2-3 hours
Estimated Time
Moderate
Difficulty Level

Task Requirements

Core Task Description

Decompose the problem with clear abstraction and refinement, show reusable components and communicate algorithms using appropriate tools (flowcharts or code).

Apply logical thinking with well-defined steps and use consistent structure and naming conventions. Communicate the design so a client can make decisions and a third party could implement the solution.

Learning Objectives

Break down complex problems using abstraction and refinement techniques
Identify and design reusable components for efficient development
Create clear algorithms using appropriate visual and textual methods
Apply consistent structure and naming conventions throughout designs
Communicate technical designs effectively to both technical and non-technical audiences
Document design decisions with clear rationale and justification

Time Management

Problem Analysis30 min
System Decomposition45 min
Algorithm Design60 min
Documentation45 min
Total Estimated3 hours

Prerequisites

Problem analysis skills
Algorithm design principles
Flowchart/pseudocode creation
System design concepts

Core Design Principles

1

Abstraction

Hide unnecessary complexity while exposing essential features

Application:

Focus on what the system needs to do, not how it does it initially

Examples:

  • • High-level system overview before detailed implementation
  • • User interface mockups showing functionality without code details
2

Decomposition

Break complex problems into smaller, manageable parts

Application:

Divide the main problem into sub-problems that can be solved independently

Examples:

  • • Login system → validation + authentication + session management
  • • E-commerce → catalogue + cart + payment + shipping
3

Pattern Recognition

Identify similarities and common patterns to create reusable solutions

Application:

Look for recurring elements that can be standardized and reused

Examples:

  • • Form validation patterns
  • • Data access patterns
  • • Error handling approaches
4

Algorithm Design

Create step-by-step solutions that are logical, efficient, and clear

Application:

Define precise processes that can be implemented by any developer

Examples:

  • • Flowcharts for business logic
  • • Pseudocode for calculations
  • • Decision trees for user journeys

Algorithm Design Guidelines

Clarity First

Algorithms must be unambiguous and easy to follow

Key Tips:

  • • Use consistent terminology
  • • Avoid jargon unless necessary
  • • Include decision points clearly

Logical Flow

Steps should follow a logical sequence with clear connections

Key Tips:

  • • Show dependencies between steps
  • • Include error handling paths
  • • Consider alternative scenarios

Appropriate Detail

Include enough detail for implementation without being overly specific

Key Tips:

  • • Focus on logic rather than syntax
  • • Include key calculations and conditions
  • • Leave implementation flexibility

Visual Communication

Use diagrams effectively to supplement textual descriptions

Key Tips:

  • • Choose appropriate diagram types
  • • Ensure diagrams are readable
  • • Align visual and textual information

Design Tools & Methods

Algorithm Visualization

Flowcharts
Pseudocode
Structured English
Decision trees
Activity diagrams

System Design

System diagrams
Component diagrams
Data flow diagrams
Entity relationship diagrams
Wireframes

Documentation

Requirements analysis
Use case descriptions
Interface specifications
Design rationale
Technical specifications

Required Deliverables

Design Pack with Algorithms

Comprehensive design documentation including system breakdown, component designs, and detailed algorithms

Format: Document with diagrams (flowcharts, system diagrams, wireframes)

70%

Explanation of Structures and Processes

Clear written explanations of how the system works, component interactions, and design rationale

Format: Written document explaining design decisions and system architecture

30%

Success Criteria & Assessment

Problem Decomposition

Clear breakdown of complex problems into manageable components
Logical hierarchy showing relationships between system parts
Appropriate level of detail for each component identified
Evidence of systematic thinking and analysis approach

Algorithm Communication

Clear, unambiguous algorithms that can be followed by others
Appropriate use of flowcharts, pseudocode, or structured English
Consistent notation and conventions throughout documentation
Algorithms demonstrate logical flow and decision-making

Reusable Components

Identification of components that can be reused across the system
Clear interfaces and responsibilities defined for each component
Components designed for maintainability and extensibility
Evidence of modular thinking and design patterns

Design Communication

Documentation suitable for both technical implementation and client review
Clear explanations of design decisions and trade-offs
Diagrams and descriptions complement each other effectively
Professional presentation that supports decision-making

Preparation Steps

1
Review problem analysis and decomposition techniques
2
Practice creating clear, implementable flowcharts and pseudocode
3
Study examples of well-designed system architectures
4
Understand the difference between high-level and detailed design
5
Learn to identify common design patterns and reusable components
6
Practice explaining technical concepts to non-technical audiences
7
Review naming conventions and documentation standards

Common Mistakes to Avoid

Insufficient problem decomposition leading to overly complex solutions
Algorithms that are too vague or ambiguous for implementation
Poor choice of visualization methods for the type of problem
Inconsistent naming conventions and notation throughout design
Lack of reusable components leading to duplicated functionality
Design documentation that is too technical for client understanding
Missing justification for key design decisions
Inadequate consideration of system interfaces and data flow
Next: Task 4a →← Previous: Task 2