IB Computer Science IA 2027: The Computational Solution

By Michael Thompson · Education Specialist; 10 years teaching the IB at Bromsgrove School · Published 4 October 2026 · Updated 6 October 2026

The IB Computer Science IA for first assessment May 2027 is called the computational solution - a piece of software you design and build yourself to solve a real-world problem of your own choosing. It is worth 30% of your final grade at SL and 20% at HL, and is allocated 35 teaching hours. Assessed across five criteria totalling 30 marks, it combines Theme A concepts and Theme B computational thinking into a single project. This guide covers every criterion, how to pick a problem with enough depth, and how to plan your 35 hours so nothing is left to the last week.

Key Takeaways

• First assessment May 2027: The new DP Computer Science course was first taught August 2025; students sitting exams in November 2026 or earlier are on the previous course.
• 30 marks across five criteria: Criterion A (4), B (4), C (6), D (12), and E (4) - Criterion D is worth as much as A, B, and E combined.
• 2,000-word documentation cap: Code excerpts, code comments, and diagrams do not count toward the 2,000-word limit; full source code goes in a separate appendix.
• A video of up to five minutes is required: The video must show the product working and provide examples of testing - it is not optional.
• No client required: Unlike the previous course's IA, you choose your own problem with no obligation to work with an external client.
• Java or Python for the course: Paper 2 is answered in Java or Python, and most schools teach just one of the two; the IA is not formally restricted to those languages, but building it in the one you study is usually the safest choice.

In This Article

1. What is the IB Computer Science IA for 2027?
2. The five IA criteria at a glance
3. What each criterion asks for in practice
4. How to choose a problem with enough computational depth
5. The video requirement and appendix rules
6. Planning your 35 hours: a practical timeline
7. Where to go from here

1. What is the IB Computer Science IA for 2027?

The IB Computer Science IA is a piece of independent work called the computational solution: a program you build to address a real-world problem of your own choosing, using the concepts, skills and tools of the course alongside the computational thinking process. It is not an essay or a research report. It is working software, documented and evidenced. As the IB's course updates page puts it, the IA brings together Theme A (Concepts of Computer Science) and Theme B (Computational Thinking and Problem-Solving), the two organising themes of the new course, which was first taught in August 2025 and is first assessed in May 2027.

The same task and the same five criteria apply at both SL and HL. What differs is the weighting: the IA counts for 30% of your final grade at SL and 20% at HL, reflecting the larger external assessment at HL. You are allocated 35 hours of teaching time to complete it.

One change worth noting early: a client is no longer required. Unlike the previous course's IA, you choose the problem yourself. There is no obligation to build something for a named user or organisation, which gives you more freedom but also removes a ready-made source of requirements.

> Note for students on the previous course. If you are sitting IB Computer Science exams in November 2026 or earlier, you are on the legacy course, which has a client-based IA with different criteria. This guide covers the 2027 course only.

2. The five IA criteria at a glance

The IB Computer Science IA is marked out of 30 across five criteria. Here is the full breakdown from the IB's Computer Science subject guide:

Criterion D alone accounts for 40% of all IA marks. It covers your development process, a fully functional product and the supporting video, so this is where problem depth and code quality count most. A project that solves a trivial problem is unlikely to score well here, however well the other criteria are met, because there is too little technical substance to explain.

Full level descriptors for each criterion are published in the subject guide, which teachers access via the Programme Resource Centre.

A few documentation rules that catch students out:

• The written documentation is capped at 2,000 words, under the IB subject guide.
• Code excerpts, code comments, and diagrams do not count toward that word limit.
• Full source code must be compiled into a separate PDF appendix, distinct from the main written document.

The practical implication: you can include detailed, well-commented code without worrying that it eats into your word count. Use that freedom deliberately.

3. What each criterion asks for in practice

Each of the five criteria has a different job, and understanding that division of labour is what stops students from writing the wrong thing in the wrong place.

Criterion A: Problem Specification (4 marks)

This is the foundation the rest of the IA is built on. You need to define the real-world problem clearly, state what your software will do and, just as important, what it will not do. Then you establish measurable success criteria, things you can test and point to as pass or fail.

The non-obvious part: those success criteria are not just for Criterion A. They thread into B (your plan should address them), C (your testing strategy should map back to them), D (your development decisions are justified against them) and E (your evaluation judges how well the product met them). Weak success criteria in A create a chain of problems across the whole IA.

Criterion B: Planning (4 marks)

Break the problem down into smaller parts and plan a solution that addresses your success criteria, with a timeline for designing, building and testing it. A Gantt chart or an Agile-style board is a common way to set this out. Keep this section tight: every sentence should show a decision or a schedule, not a description of what computer science is.

Criterion C: System Overview (6 marks)

This criterion covers your system model (usually diagrams), the algorithms behind it (written as pseudocode or flowcharts, for example) and your testing strategy. Link that testing strategy back to the success criteria you set in A, and keep the written explanation short so the visual material does the work.

Criterion D: Development (12 marks)

At 12 of the 30 available marks, this is where the IA is won or lost. The product must be fully functional, and the criterion also covers your development process and the supporting video. Explain why you chose each technique rather than just describing it, include well-commented code segments, and use the video to show your testing. Saying "I used a binary search because it is efficient" is description. Saying "I chose binary search over linear search because the records are kept sorted by ID, so each lookup takes O(log n) comparisons instead of O(n), which keeps searches fast as the dataset grows" is justification.

Criterion E: Evaluation (4 marks)

Return to the success criteria from A and assess honestly whether the product met each one. Identify genuine limitations and propose realistic future improvements. An evaluation that claims everything worked perfectly is rarely credible and rarely scores well.

Per ManageBac, the IA is marked out of 30 across these five criteria, with the total split as A(4), B(4), C(6), D(12), E(4).

4. How to choose a problem with enough computational depth

The problem you pick determines whether Criterion D is straightforward or painful. Criterion D is worth 12 of the 30 available marks, and you want your development process to show real decisions you can explain, not just code that runs. A problem that is too thin gives you nothing interesting to justify.

The problem must be real-world and of your own choosing. Unlike the previous IB Computer Science IA, the 2027 course removes the client requirement entirely. You do not need to find an external person to interview or satisfy. The problem still has to be grounded in a genuine context, but the scope is yours to define.

What "computational depth" actually means for Criterion D

A problem has enough depth when its solution requires more than one of the following, working together:

• Algorithmic thinking: sorting or searching a dataset, implementing a pathfinding or filtering routine, applying a simple ML model (machine learning is now in the syllabus for all students, with the modelling approaches at HL, per the 2027 subject brief)
• Data structures: using lists, dictionaries, stacks, or queues in a way that a flat spreadsheet could not replicate
• OOP or database interaction: designing classes, or querying a relational database with SQL, both of which are now core syllabus content for all students under the 2027 course

A form that writes to a text file, or a static webpage with conditional display logic, does not clear this bar. The common trap is that projects framed around a user interface often look large but are computationally shallow. Substance lives in the back-end logic, not the front end.

The scope test

Before committing to a problem, run this check:

1. Can you state three measurable success criteria for it? If not, the problem is not defined precisely enough for Criterion A.
2. Can a working solution realistically be built, tested, and documented inside 35 hours? If not, the scope is too wide.
3. Does the solution require at least two distinct computational techniques you can genuinely explain and justify? If not, the scope is too narrow for Criterion D.

A library management system that sorts books by genre, queries a database of loans, and flags overdue items using a class hierarchy passes all three checks. A to-do list app with an add/delete function does not pass check three.

Use the course language, Java or Python, if you can: the subject brief says the course can be studied in either. Most schools teach one of the two to the whole class, so choose a problem you can build in the language you are already learning.

5. The video requirement and appendix rules

The 2027 IB Computer Science IA requires a video of at most five minutes, showing the product working and examples of testing. The critical point students often miss: the video is your testing evidence for Criterion D, not a walkthrough of your written report. Narrating your methodology or reading out your design diagrams wastes the five minutes and leaves Criterion D without adequate demonstration.

Keep the video task-focused. Show the product handling real inputs, including edge cases and error conditions. If your success criteria from Criterion A include handling invalid data gracefully, the video is where you prove it happens.

On submission structure, two separate documents are required:

• Main written documentation - capped at 2,000 words; code excerpts, comments, and diagrams do not count toward this limit.
• Appendix (separate PDF) - full source code and any student-developed resources compiled here; this document is distinct from the main submission and does not affect the word count.

This means your teacher and the IB moderator can read your complete code without it inflating your documentation length. That said, the code excerpts you include inside the main document still need to be the right ones: selected, annotated segments that justify your technique choices, not a paste of everything (that belongs in the appendix).

6. Planning your 35 hours: a practical timeline

The IB Computer Science IA is allocated 35 hours, and how you distribute those hours matters as much as how you spend them. The most common mistake is treating development as one long coding sprint at the end. That approach leaves almost no material to justify your technique choices in Criterion D, which carries 12 of the 30 available marks.

Split the 35 hours across five phases, each aligned with the criteria that generate the evidence for it.

Phase timeline at a glance

Phase 1: Problem selection and research (~5 hrs) Define the problem and write at least three measurable success criteria in plain language before you write a single line of code. Criterion A is only 4 marks, but a vague problem statement propagates through every criterion that follows it.

Phase 2: Planning and design (~7 hrs) Produce your plan (a Gantt chart or an Agile-style board are common choices), your system diagrams, and pseudocode or flowcharts. Keep your Criterion C diagrams in step with what you actually build, and update them if the design changes during development.

Phase 3: Development, iterative builds (~16 hrs) Build in stages: a working skeleton first, then features one at a time. Each iteration gives you a discrete decision to justify in Criterion D commentary. A session where you implement, hit a problem, and pivot to a different algorithm is exactly the kind of development process worth recording for Criterion D.

Phase 4: Testing and video recording (~4 hrs) The IA requires a video of at most five minutes showing the product working and examples of testing. Record last, but plan your test cases during Phase 2 so you know what the camera needs to capture.

Phase 5: Evaluation and write-up (~3 hrs) The total documentation is capped at 2,000 words (code excerpts and diagrams do not count toward this limit). Use every word deliberately.

Self-check per criterion before you submit

• Criterion A: Can you state the problem and every success criterion in plain language, without referring to your code?
• Criterion B: Does your plan show a milestone for each distinct feature, not just a single "build" block?
• Criterion C: Do your diagrams and pseudocode reflect the product you actually submitted, not your original design?
• Criterion D: Is every significant technique justified in your write-up and commented in the code itself?
• Criterion E: Does your evaluation reference each success criterion from Criterion A by name, with evidence from your testing?

That last check is the one most often missed. Criterion E has nowhere to go if Criterion A's success criteria were never specific enough to test against.

7. Where to go from here

One check settles more than you might expect: confirm with your teacher this week that you will build your IA in the language your class is taught, Java or Python. The answer matters immediately because Paper 2 is answered in Java or Python, and your IB Computer Science IA is far easier to build in the language you are taught. Switching halfway through the course is costly, and the choice shapes which libraries, data structures, and object-oriented patterns you practise from day one.

Once you know the language, sketch a one-sentence problem statement for a real-world scenario you could realistically solve in code. Run it past your teacher for a quick feasibility check before you commit any hours to it. That conversation, language confirmed and problem scoped, is the most productive 15 minutes you can spend right now. Everything else follows from those two decisions. If you are also thinking about an extended essay in computer science, our IB Computer Science extended essay guide covers that separately.

FAQ

What is the IB Computer Science IA?

The IB Computer Science IA (first assessment 2027) is the computational solution - a coded software project that solves a real-world problem of the student's own choosing, assessed across five criteria totalling 30 marks and worth 30% at SL or 20% at HL.

Is there a word count limit for the IB Computer Science IA?

The written documentation is capped at 2,000 words; code excerpts, code comments, and diagrams are excluded from this count, and full source code is placed in a separate PDF appendix.

Do I need a client for the IB Computer Science IA?

No - unlike the previous course's IA, the 2027 computational solution does not require a client; you choose your own real-world problem.

What is the video requirement for the IB Computer Science IA?

Students must submit a video of at most five minutes showing the product working and providing examples of testing; this video forms part of the evidence assessed under Criterion D.

Is the IB Computer Science IA the same at SL and HL?

Yes - the task, criteria, word count, and video requirement are identical at SL and HL; the only difference is the weighting (30% at SL, 20% at HL).

When is the first assessment for the new IB Computer Science course?

The new course was first taught in August 2025 and is first assessed in May 2027; students sitting exams in November 2026 or earlier are on the legacy course.

References

• Computer science updates - International Baccalaureate - https://www.ibo.org/university-admission/latest-curriculum-updates/computer-science-updates/
• New Computer Science Guide: What to Expect | Subject Support - ManageBac+ - https://www.managebac.com/subject-support/new-computer-science-guide-what-to-expect
• Diploma Programme Subject Brief - Computer science, first assessment 2027 (International Baccalaureate Organization 2024) - https://www.ibo.org/globalassets/new-structure/university-admission/pdfs/dp_comp_sci_subjectbrief_en.pdf