Planning the Solution

students, imagine you have been asked to build a simple app for a school canteen 🍎. Before you touch the keyboard, you need a clear plan: what problem are you solving, who will use it, what data will it handle, and how will you know it works? That is the purpose of planning the solution in IB Computer Science SL.

Lesson objectives

Explain the main ideas and terminology behind planning the solution.
Apply IB Computer Science SL reasoning to plan a computational solution.
Connect planning the solution to the wider topic of computational solution.
Summarize how planning fits into the full development process.
Use examples from real-world computing to support your understanding.

In this lesson, you will learn how good planning turns a vague idea into a workable system. Planning is not just writing a list of features. It means understanding the problem, identifying users, defining requirements, choosing suitable methods, and preparing for development, testing, and evaluation. In IB Computer Science, this stage is closely linked to the internal assessment because your solution must be client-focused, practical, and justified by evidence.

What Planning the Solution Means

Planning the solution is the stage where you move from “What should I make?” to “How will I make something that meets the client’s needs?” It is one of the most important parts of computational solution because every later decision depends on it.

A good plan usually includes:

the problem definition,
the client or user needs,
clear success criteria,
the required inputs, processes, and outputs,
design ideas for the system,
and a plan for testing and development.

Think of planning like building a house 🏠. You would not start with the roof. First, you need the blueprint, the size of the rooms, the materials, and the purpose of each space. In the same way, a computer solution needs a blueprint before it is built.

In IB Computer Science SL, planning is especially important because the internal assessment is not just about coding. It is about solving a real problem for a real client. That means your plan must show that you understand the user and the context.

Understanding the Problem and the Client

The first job in planning is to understand the problem clearly. If the problem is unclear, the final solution may look impressive but fail to help the client.

You should identify:

the client: the person or organization that needs the solution,
the user: the person who will actually use it,
the problem: what difficulty needs to be solved,
the context: where and how the problem happens.

For example, students, suppose a school librarian needs a better way to track borrowed books. The client may be the librarian, but the users may include students and staff. The problem is not just “make a database.” The real problem may be that current records are slow, inaccurate, or easy to lose.

Good planning often begins with research and communication. You may gather information through interviews, observations, questionnaires, or document analysis. This helps you avoid guessing. If the client says, “I need a system for managing payments,” you may need to ask follow-up questions such as:

What data must be stored?
Who will enter the data?
What reports are needed?
What problems happen with the current method?

This stage is about accuracy and clarity. A solution built on assumptions is likely to fail.

Defining Requirements and Success Criteria

Once the problem is understood, the next step is to define what the solution must do. These are called requirements. Requirements can be functional or non-functional.

Functional requirements describe what the system must do.
Non-functional requirements describe how the system should perform or behave.

For example, for a canteen ordering system:

Functional requirement: The system must allow users to select items and place orders.
Functional requirement: The system must calculate the total cost.
Non-functional requirement: The interface should be easy to use on a phone.
Non-functional requirement: The system should load quickly.

A very important part of planning is creating success criteria. These are measurable statements that let you judge whether the solution has met the client’s needs. Good success criteria are specific and testable.

Examples:

The system will allow a user to submit an order in fewer than $3$ steps.
The database will store at least $100$ records without losing data.
The output report will show the total sales for each day.

These criteria matter because they connect planning to evaluation. Later, you can test whether the finished solution achieved what it was supposed to achieve.

Breaking the Problem into Inputs, Processes, and Outputs

A useful planning method is to think about inputs, processes, and outputs.

Inputs are the data that enters the system.
Processes are the actions or operations carried out on the data.
Outputs are the results produced by the system.

For example, in a quiz scoring system:

Input: student answers
Process: compare answers with the correct solutions and calculate the score
Output: final score and feedback

This structure helps you think logically. It also supports computational thinking because you are breaking a large problem into smaller parts.

You may also need to identify data types and data structures. For example, a student ID might be an integer, while a name is text. If a system needs to store a list of orders, an array or table might be appropriate. Planning these details early can prevent problems later during development.

If the solution requires formulas, calculations, or decision-making, these should also be planned clearly. For example, a delivery app might need to compute a cost using a formula like $\text{total} = \text{item cost} + \text{delivery fee}$. If there is a discount for large orders, the plan should explain the rule in words and in calculation form.

Designing the Structure of the Solution

Planning also includes deciding how the solution will be organized. This is sometimes called design. Good design makes the system easier to build, test, and use.

Depending on the project, design may include:

flowcharts,
structure diagrams,
wireframes or screen layouts,
pseudocode,
data models,
and algorithm descriptions.

For a student grade tracker, a wireframe might show a login screen, a data entry page, and a summary report page. A flowchart might show the steps for adding grades, checking validity, and displaying results.

This stage is not about perfect artwork ✏️. It is about communication. The design should be clear enough that someone else could understand how the system will work.

Good design also considers usability. For example, a checkout screen should use clear labels, simple buttons, and logical navigation. If the client is a busy teacher, the system should reduce extra steps. If the user is a younger student, the interface should be simple and familiar.

Planning with the user in mind is a major part of client-focused design. It ensures that the final product is not only functional but also appropriate for the intended audience.

Planning for Development and Testing

A strong plan does not stop at design. It also prepares for development and testing.

During development planning, you may decide:

what programming language or platform to use,
what modules or parts the solution will have,
what sequence to follow when building features,
and which tools or resources are needed.

During testing planning, you decide how to check that the solution works correctly. Testing should be linked to success criteria. For example, if a success criterion says the user can save a record, the test should check whether saving works with valid data and whether the system handles invalid data correctly.

Testing may include:

normal test data,
extreme test data,
invalid test data.

Example for a price calculator:

Normal data: $5$ items at $2$ each.
Extreme data: a very large number of items.
Invalid data: letters entered where numbers are required.

This helps you find errors before the solution is used in real life. In IB Computer Science, testing is not an afterthought. It is part of responsible solution development.

Why Planning Connects to the Whole Computational Solution

Planning is not separate from the rest of the topic. It connects directly to development, testing, evaluation, and documentation.

Here is how the stages fit together:

Planning identifies the problem, user, requirements, and design.
Development turns the plan into a working solution.
Testing checks whether the solution works as intended.
Evaluation compares the final product with the success criteria.
Documentation explains the system, how it works, and how it should be used.

If planning is weak, the whole project suffers. A poor plan can lead to missing features, confusing interfaces, or testing that does not match the real requirements.

For example, imagine a club attendance system. If the plan forgets that the system must work on shared school devices, the final product may require private logins that the client cannot use. That kind of mistake is often caused by incomplete planning.

A good plan makes the later stages much easier. It gives direction, reduces wasted effort, and helps you justify your design decisions. That is why planning is a key part of the internal assessment process.

Conclusion

Planning the solution is the foundation of a successful computational solution. It begins with understanding the client and the problem, then moves to defining requirements, setting success criteria, designing the structure, and preparing for development and testing. In IB Computer Science SL, this process is essential because solutions must be practical, client-focused, and supported by evidence.

students, if you remember one idea from this lesson, remember this: good planning saves time, improves quality, and makes it far more likely that the final solution will actually solve the problem. A clear plan is not extra work — it is the path to building the right solution ✅.

Study Notes

Planning the solution means preparing a clear, client-focused blueprint before development begins.
The first step is understanding the client, the user, the problem, and the context.
Requirements describe what the solution must do; success criteria make those requirements measurable.
Functional requirements describe system actions; non-functional requirements describe performance or usability.
Inputs, processes, and outputs help organize the problem logically.
Design tools may include flowcharts, wireframes, pseudocode, structure diagrams, and data models.
Planning should consider usability, data types, storage, and user needs.
Development planning decides how the solution will be built.
Testing planning should use normal, extreme, and invalid data.
Planning connects directly to development, testing, evaluation, and documentation.
In IB Computer Science SL, strong planning supports the internal assessment and improves the final solution.