- Which Computer Science IA Model Applies to You?
- Criteria for May and November 2026 Exams (34 Marks)
- Criteria From May 2027: The Computational Solution (30 Marks)
- What Makes a Strong Computer Science IA?
- Choosing a Problem and Scoping the Product
- Computer Science IA Ideas That Scope Well
- Planning Evidence for the Criteria
- Testing and Evaluation Should Be Evidence-Based
- Making the Video
- Common Computer Science IA Mistakes
Quick Answer
The IB Computer Science IA is a software product you plan, build, test and evaluate, documented in up to 2,000 words plus a video. For May or November 2026 exams, the old 34-mark model applies and needs a real client. From May 2027, the new computational solution applies: about 35 hours, 30 marks, a video of up to 5 minutes and no client requirement.
What You'll Learn
- Exams in May or November 2026 use the previous IA, marked out of 34 and built for a real client; exams from May 2027 use the new computational solution, marked out of 30
- In both models the IA is worth 30% of the grade at SL and 20% at HL, with documentation capped at 2,000 words plus a video
- From 2027 the five criteria are problem specification (4), planning (4), system overview (6), development (12) and evaluation (4)
- Development carries 12 marks in both models, so the techniques you use and how clearly you explain them matter most
- A tightly scoped product that works and is well documented beats an ambitious one that is half finished
Which Computer Science IA Model Applies to You?
The IB published a new Computer Science guide for first teaching in August 2025, with first assessment in May 2027. Your exam session decides which version of the IA you complete, so confirm it with your teacher before you choose a project.
- May or November 2026 exams: the previous guide applies. You build a solution for a real client, document it in up to 2,000 words and submit a video of 2 to 7 minutes showing it working. It is marked out of 34 across five criteria.
- May 2027 exams onwards: the new guide applies. You build a computational solution to a real-world problem of your own choosing in about 35 hours, document it in up to 2,000 words (code excerpts, code comments and diagrams are excluded) and submit a video of up to 5 minutes. It is marked out of 30 across five new criteria, and a client is no longer required.
- Weighting in both models: 30% of the final grade at SL and 20% at HL
- New exams from May 2027: SL sits Paper 1 and Paper 2 (1 hour 15 minutes and 35% each), and HL sits Paper 1 and Paper 2 (2 hours and 40% each). The pre-released case study is now part of Paper 1 at both levels.
- Alongside the new IA, students on the new course also complete the 10-hour collaborative sciences project
Watch Out
Much of the advice online, including most exemplars, was written for the previous model. It is right for 2026 candidates, but if you sit your exams in 2027, the criteria, the video length and the client rules are different.
Criteria for May and November 2026 Exams (34 Marks)
Under the previous guide, your product is built for a real client, and the documentation shows how you planned, designed, developed and evaluated it.
- A. Planning (6 marks): describe the client's scenario, explain why your proposed product suits it and set specific, testable success criteria
- B. Solution overview (6 marks): a record of tasks and a design overview that includes an outline test plan
- C. Development (12 marks): explain the techniques you used, such as data structures, algorithms and libraries, why they were appropriate, and acknowledge any sources
- D. Functionality and extensibility of product (4 marks): the video shows the product working, and the design and code are structured so someone else could extend it
- E. Evaluation (6 marks): evaluate the product against the success criteria, using client feedback, and recommend realistic improvements
Criteria From May 2027: The Computational Solution (30 Marks)
The new IA puts the computational thinking process at the centre and brings together both halves of the course: how computing systems work and how you use them to solve problems. You choose any real-world problem that is complex enough to need a substantial solution, and no external client is required.
- A. Problem specification (4 marks): describe the problem in terms of measurable requirements, set appropriate success criteria and explain why a computational solution fits
- B. Planning (4 marks): break the problem down into manageable parts and produce a plan that addresses the success criteria
- C. System overview (6 marks): a complete model of the system, algorithms for its components and a testing strategy aligned with the success criteria
- D. Development (12 marks): a fully functional product built with appropriate techniques, with your implementation choices evaluated and your testing strategy justified
- E. Evaluation (4 marks): evaluate how far the success criteria were met and justify realistic improvements
Pro Tip
Include your full source code in the way your teacher instructs. Development marks depend on the moderator being able to check the techniques you describe.
What Makes a Strong Computer Science IA?
In both models, Computer Science IAs score well when they combine technical skill with clear evidence. Examiners want to see that you understood a real problem, set success criteria you could test, chose techniques for good reasons, built the product systematically and judged honestly whether it works. The largest single block of marks, 12 for development, rewards explaining your techniques and choices, not just using them.
Pro Tip
Your project should solve a genuine problem, not just show that you can code. A simple-looking product with well-explained algorithms and data structures often scores better than a flashy one with thin documentation.
Choosing a Problem and Scoping the Product
Weak IAs often fail because the scope is unclear. For 2026 exams you need a believable client with a specific need. From 2027 you can pick any problem that interests you, as long as it is complex enough. Either way, you need success criteria that can be tested and evaluated later.
- 2026 model: identify a real client, such as a teacher, a club or a small business, and consult them about the problem
- 2027 model: choose a real-world problem with enough complexity to need decomposition, algorithms and meaningful data handling
- Write success criteria that are specific and measurable, for example that a search returns results in under one second
- Keep the scope small enough to finish, test and document thoroughly
- Choose features that serve the problem rather than adding extras for show
Watch Out
A project with too many features usually weakens the evidence for design, testing and evaluation, because none of them gets documented properly.
Computer Science IA Ideas That Scope Well
These ideas are illustrative. Each names the techniques it gives you to explain in development. Adapt them to a real problem you or a client actually have.
- A booking system for practice rooms or sports courts: a database, input validation and clash detection between bookings
- An inventory and loan tracker for a club or department: relational data, searching and sorting, and overdue alerts
- A revision flashcard app with spaced repetition: a scheduling algorithm, saved user data and progress statistics
- A weather station dashboard: reading sensor or open data files, cleaning the data and plotting trends
- A route finder for a school site: a graph data structure and a shortest-path algorithm such as Dijkstra's
- A tournament manager for a school league: fixture generation, standings calculation and tie-break rules
- A personal budget tracker: categorised transactions, recurring payments and summary reports
- A recipe scaler and shopping list builder: unit conversion, parsing ingredient text and combining quantities
- A subject-option clash checker: checking constraints across many timetable combinations
- A puzzle or text adventure game with save files: object-oriented design, game state and file handling
Watch Out
Complexity should come from the problem, not from piling on features. A few well-chosen techniques, each explained and tested, give the development criterion more to reward than a long feature list.
Planning Evidence for the Criteria
A strong IA is not only about building the product. It is about documenting the process clearly enough to satisfy every criterion. Many students build something that works and then lose marks because the evidence is thin or disorganised. This order of work keeps the evidence building as you go.
- 1Define the problem and success criteria first, and in the 2026 model record your consultation with the client
- 2Break the problem into parts and plan the order you will build them in
- 3Produce design evidence before coding: system diagrams, data structures, algorithms in pseudocode or flowcharts, and interface sketches
- 4Write your test plan alongside the design, with each test linked to a success criterion
- 5Build in stages and keep notes on the techniques you use and why, ready for the development section
- 6Test systematically with normal, boundary and invalid data, and record the results
- 7Record the video, then evaluate each success criterion with evidence
Testing and Evaluation Should Be Evidence-Based
The strongest Computer Science IAs show whether the product actually solves the problem it was built for. Testing should cover functionality, edge cases and user needs, and the evaluation should judge the product against the original success criteria rather than describe its features.
- Test expected functionality and boundary cases, and show how the product handles invalid input
- Show evidence of debugging and refinement, not just a final test table
- Include user or client feedback where it fits your model
- Evaluate how well each success criterion was met, with evidence
- Suggest realistic improvements and explain why they would help
Making the Video
The video is your evidence that the product works. For 2026 exams it should run 2 to 7 minutes; from May 2027 the maximum is 5 minutes. Plan it before you record.
- Follow the order of your success criteria so the moderator can tick them off
- Use realistic data, not a few placeholder entries
- Show validation and error handling, not only the happy path
- Cut set-up time and long loading screens to stay within the limit
- Check the recording is clear enough to read text on screen
Common Computer Science IA Mistakes
These issues often limit marks in otherwise promising projects. An IB Computer Science tutor can explain what makes success criteria testable and how evidence lines up with each criterion, using examples rather than your own project.
- Following an exemplar or rubric written for the wrong model
- An overambitious project that cannot be finished properly
- Success criteria that are too vague to test
- Screenshots of code without explanation of the technique or why it was chosen
- Code you cannot explain, including code from tutorials or AI tools that is not acknowledged
- A video that skips the features your success criteria promise
- An evaluation that describes the product instead of judging it against the success criteria