Identifying a Client and Problem 🤝💻

Welcome, students. In IB Computer Science SL, the first important step in creating a computational solution is understanding who the client is and what problem needs to be solved. If this step is done well, everything that follows—design, development, testing, and evaluation—becomes clearer and more effective. If it is done poorly, the final solution may look impressive but still fail to meet the real need.

Lesson objectives:

• Explain the main ideas and terminology behind identifying a client and problem.
• Apply IB Computer Science SL reasoning to a real-world situation.
• Connect this step to the wider process of computational solution development.
• Summarize why client identification and problem definition matter in the IA and beyond.
• Use examples and evidence to support understanding.

Think of it like building a custom app for a school club, a small business, or a local charity. The key question is not just “What can I program?” but “What does this person or organization actually need?” 📱

What is a client, and why does the client matter?

In the IB Computer Science IA, the client is the person, group, or organization that has a need and will use or benefit from the final computational solution. The client may be a teacher, student, shop owner, coach, librarian, NGO worker, or administrator. A good client is someone with a real problem that can be improved using technology.

students, the client matters because the solution must be client-focused. That means the system should be designed around the client’s needs, not the developer’s personal preferences. For example, if a school librarian needs a way to track borrowed books, a solution that looks colorful but does not record due dates would not be useful. The client’s workflow, goals, and constraints should shape the project.

A client also helps define the scope of the project. Scope means the set of features and tasks the solution will include. Without a client, the project can become too vague. With a clear client, the developer can ask better questions such as:

• What problem are they facing?
• How often does it happen?
• What data do they need to store or process?
• What limitations do they have, such as time, budget, or skill level?

These questions lead to a solution that is realistic and useful.

Identifying the problem clearly

A problem in IB Computer Science is not simply a general inconvenience. It is a specific need that can be addressed with a computational solution. A strong problem statement explains what is wrong, who is affected, and why a digital solution would help.

For example, “The café is busy” is too vague. A better problem statement would be: “The café owner needs a faster way to record customer orders during peak hours because handwritten order slips are often lost, causing delays and mistakes.” This version identifies the user, the issue, and the reason a computer-based solution is needed.

Good problem identification should include:

• the client’s current situation
• the main difficulty or inefficiency
• the impact of the problem
• any constraints or requirements

A problem is strongest when it is based on evidence, such as observation, interview responses, or existing records. This is important in the IB IA because the solution should be justified by real information rather than assumptions. 📊

How to gather information from a client

To identify the client and problem properly, the developer must collect information. In the IA, this often happens through interviews, questionnaires, observation, and document analysis.

Interview

An interview is a direct conversation with the client. It allows the developer to ask follow-up questions and clarify details. For example, if a sports coach wants a team attendance tracker, the developer can ask how attendance is currently recorded and what information must be saved.

Questionnaire

A questionnaire is useful when feedback is needed from many people. It can help identify trends, preferences, or common issues. For example, a school club might survey members to learn what features they want in an event booking system.

Observation

Observation means watching the client’s current process in action. This is valuable because people may forget details when explaining what they do. By observing a receptionist entering visitor data, a developer may notice repeated steps or bottlenecks.

Document analysis

This involves examining forms, spreadsheets, reports, or logs already used by the client. These materials provide evidence of how the current system works and where it fails.

Using more than one method gives a better understanding. A single interview may not show the full picture, but combining observation and documents can reveal patterns and practical needs.

Turning a vague need into a manageable problem

A major skill in computational solution planning is transforming a broad need into a clear and manageable problem. This is important because a solution must be specific enough to build within available time and resources.

Suppose a school wants “better communication.” That is too broad for an IA project. The problem could be narrowed to: “The school drama club needs a system to share rehearsal schedules and track attendance because messages are currently sent through multiple chats, causing confusion.” Now the problem is concrete and measurable.

A useful way to check whether a problem is manageable is to ask:

• Can it be solved with available tools and time?
• Is the data needed accessible?
• Can the final product be tested fairly?
• Does it have a clear purpose?

In IB Computer Science SL, this is a crucial part of internal assessment preparation because the chosen problem should allow meaningful development, testing, and evaluation.

Linking the client and problem to the computational solution process

Identifying the client and problem is the starting point of the full computational solution cycle. It directly affects later stages:

• Design: The requirements come from the client’s needs.
• Development: The program is built to meet those needs.
• Testing: The solution is checked against the identified problem.
• Evaluation: The final product is judged by how well it solves the client’s problem.
• Documentation: The reasoning and decisions must be recorded clearly.

This is why client-focused design is central to the IB approach. A solution is not successful just because it runs without errors. It is successful when it solves the correct problem for the correct client.

For example, imagine a local bakery client who needs to track daily sales. A spreadsheet system might be the best choice if the bakery mainly wants to calculate totals and spot popular items. A complex app with login systems, maps, and messaging would add unnecessary complexity. The right solution depends on the client’s actual problem.

Common mistakes to avoid

students, students often make a few common mistakes when identifying a client and problem:

• choosing a client with no clear need
• writing a problem statement that is too broad
• designing a solution before understanding the client
• relying on assumptions instead of evidence
• ignoring constraints such as time, user ability, or available data

Another mistake is focusing on what is technically interesting instead of what is useful. For IB, the strongest projects are not always the most advanced ones. They are the ones that show clear evidence of understanding the client, defining the problem well, and building a solution that fits the need.

A strong project often starts with a simple but meaningful problem. For example, helping a tutor track student progress may be more suitable than attempting to build a full school management system. The smaller problem can still show excellent analysis, design, and testing.

Example: from client need to project idea

Consider a client who is a school sports coordinator. They say that tracking students’ participation in events takes too much time because records are stored in different places.

A good process might look like this:

1. Interview the coordinator to learn how records are currently stored.
2. Observe the existing method and identify repeated tasks.
3. Review sample attendance sheets or event lists.
4. Define the problem: a central system is needed to store participation records and quickly generate summaries.
5. Decide the scope: maybe the solution will store student names, event names, and participation counts.
6. Plan testing: check whether records can be added, searched, and summarized correctly.

This shows how identifying the client and problem leads directly into development. The clearer the beginning, the smoother the rest of the project becomes.

Conclusion

Identifying a client and problem is one of the most important early stages in IB Computer Science SL. It ensures that the computational solution is based on real needs, not guesses. By understanding the client, gathering evidence, and writing a clear problem statement, students can create a focused and useful project. This step supports the whole process of computational solution development, from design to testing and evaluation. In the IA, strong client identification shows that the solution is purposeful, realistic, and grounded in evidence. 🌟

Study Notes

• A client is the person, group, or organization that needs and uses the solution.
• The problem should be specific, evidence-based, and suitable for a computational solution.
• Client-focused design means building the solution around the client’s real needs.
• Useful information can be gathered through interviews, questionnaires, observation, and document analysis.
• A strong problem statement explains what is wrong, who is affected, and why a digital solution is needed.
• The problem should be manageable within the available time, tools, and scope.
• Identifying the client and problem shapes design, development, testing, evaluation, and documentation.
• Good IB projects solve a real problem for a real client and are supported by evidence.
• Clear early planning leads to a stronger internal assessment and a more effective final product.