IB Computer Science IA Ideas for the New Syllabus (2027)
20 IB Computer Science IA ideas for the new course (first exams 2027), plus the new criteria, word limit, video rules, pitfalls and a checklist.
By Yuness, qualified Computer Science teacher and former Head of KS5 Computer Science · Last reviewed 21 November 2026
The internal assessment (IA) in the new IB Computer Science course (first exams May 2027) is a "computational solution": you choose a problem, then plan, design, code, test and evaluate a working software product. The IB's published subject brief gives it 30% of the grade at SL and 20% at HL, with 35 hours of teaching time at both levels. The IA section of the subject guide, which most students see through their teacher or published summaries, sets out documentation of up to 2,000 words, a video of up to five minutes and an appendix with your full source code. The best ideas are small enough to finish but contain real algorithmic thinking, which is what the 20 starting points below are built around.
The new IB CS IA at a glance (first assessment 2027)
The IB launched the new course in February 2025 for first teaching in August 2025, with first assessment in May 2027, according to the IB's computer science updates page. The name, hours and weighting below are confirmed by the IB's own public subject brief (first assessment 2027). The full subject guide is only available to schools through the IB's Programme Resource Centre, so the word limit, video length, appendix and marks come from a copy of the guide's internal assessment section shared online by teachers, and from independent summaries such as Faria/ManageBac's overview of the new guide. All the sources we checked agree on these figures as of November 2026, but your teacher's copy of the current guide is the final word.
| Feature | SL | HL |
|---|---|---|
| Name of the IA | Computational solution | Computational solution |
| Recommended hours | 35 | 35 |
| Weighting of final grade | 30% | 20% |
| Documentation (one PDF) | Max 2,000 words | Max 2,000 words |
| Video | Max 5 minutes | Max 5 minutes |
| Appendix (separate PDF) | Full source code | Full source code |
| Total marks | 30 | 30 |
Code excerpts, code comments and diagrams do not count towards the 2,000 words, and the word count goes on the first page. The video must show the product's full functionality and examples of your testing strategy.
One note on weighting: a sentence on the IB's updates page says both levels are 80% external and 20% internal, but the table on the same page, and the subject brief, give 30% internal at SL and 20% at HL. The 30%/20% split is the one that matches the official assessment outline.
What changed from the old IA
- More time: 35 recommended hours, which ManageBac notes is five more than before.
- No compulsory client: ManageBac's summary of the new guide says there is no longer a requirement to involve a client, so you can pick any problem that interests you.
- Five new criteria, 30 marks: the criteria are now Problem specification, Planning, System overview, Development and Evaluation.
- The course around it changed too: machine learning (A4), databases (A3) and object-oriented programming (B3) are studied at both SL and HL, abstract data types (B4) are HL only, and the course is taught in Python or Java (subject brief). That opens up more IA directions than the old syllabus did.
The five IA criteria and what a strong IA shows
The guide gives a recommended word count for each section. They are guidance, not separate limits, but they add up to 2,000 and tell you where the marks are.
| Criterion | Marks | Suggested words | What the top band asks for (paraphrased) |
|---|---|---|---|
| A: Problem specification | 4 | 300 | The problem described in terms of measurable requirements, appropriate success criteria, and an explanation of the choice of computational context |
| B: Planning | 4 | 150 | A sensible decomposition into sub-problems and a plan (for example a Gantt or Agile chart) that addresses the success criteria |
| C: System overview | 6 | 150 | A complete system model (diagrams of components, connections and the user interface), algorithms the product needs, and a testing strategy linked to the success criteria |
| D: Development | 12 | 1,000 | A fully functional product, appropriate techniques to implement the algorithms, evaluation of the choices made, and justification of how effective the testing was |
| E: Evaluation | 4 | 400 | How far each success criterion was met, and justified improvements |
Reading the descriptors together, a strong IA has four features:
- Measurable success criteria. They are used in four of the five criteria, so "the app is easy to use" will cost you marks in A, B, C and E. "Finds a clash-free timetable for 40 events in under 2 seconds" can be tested and evaluated.
- Visible algorithmic thinking. The guide asks for a problem of sufficient complexity, with enough innovation to show organisation, algorithmic thinking and coding ability. The logic should live in your code, not in a library or a drag-and-drop builder.
- A design someone else could rebuild. Criterion C is meant to be detailed enough for a third party to recreate the product, so your diagrams and pseudocode must match what you actually built.
- Testing as evidence, not decoration. Your testing should cover unexpected and incorrect inputs as well as normal ones, and the video should show real test cases running.
What the guide says is not appropriate
The IA section of the guide rules out the following. Check any idea against this list before you start:
- products built only from copied code;
- websites made from a template that fixes the structure and layout;
- sample databases or templates that ship with software;
- copied games without major, properly documented changes to the code;
- applications made with a builder, wizard or drag-and-drop tool with no code development;
- anything that breaks the ethical requirements: you need consent from people involved before you start, written permission from the owner of any existing system you use, secure storage of collected data, and original data where possible.
Using existing code libraries is allowed and can be part of your planning research, but your own modifications and logic must be clear.
20 IB Computer Science IA ideas, grouped by type
These are starting points, not approved titles. Your teacher has to agree your problem, and the current IB guide is the final word on what is acceptable. Each idea should be narrowed to a specific user and a specific problem before you write Criterion A.
Data and database applications
These build on A3 database fundamentals: relational design, SQL queries and validation.
- Equipment loan and booking system. Problem: a department loses track of who has borrowed kit and double-books it. User: a PE, music or science technician. Complexity: several linked tables, SQL joins, overdue logic and booking-clash detection. Risk: it turns into a set of forms that add and delete records; make the clash and overdue logic the centre of the project.
- Stock and reorder tracker for a small business. Problem: a café or shop reorders by guesswork. User: the owner. Complexity: reorder-point calculations, aggregate queries for sales reports, input validation. Risk: real business data needs written consent and secure storage; do not drift into full accounting.
- Pantry-based recipe matcher. Problem: a family wastes food because they cannot see what they can cook with what they have. User: a parent or student cook. Complexity: matching and ranking recipes by ingredients available (set operations), scaling quantities, a recipe database. Risk: letting a third-party recipe API do the matching for you.
- School event room-clash checker. Problem: clubs and events are booked into rooms that are already in use. User: an activities coordinator. Complexity: interval-overlap detection, sorting, a database of rooms and events, suggestions for free slots. Risk: you will probably not get access to the school's real system, so plan to use your own sample data from the start.
Object-oriented simulations
Simulations are a natural fit for B3 OOP with multiple classes, and HL students can use queues and other structures from B4 abstract data types.
- Traffic junction simulator. Problem: compare light-timing strategies at a busy junction. User: a geography class studying congestion. Complexity: classes for vehicles, lanes and lights, queues, random arrivals, average-wait statistics. Risk: spending your hours on animation instead of the model.
- Canteen queue simulator. Problem: how many tills are needed at lunch to keep waits under a target. User: the catering manager. Complexity: queue structures, event timing, repeatable experiments with different settings. Risk: collecting real arrival data involves people, so get permission first.
- Agent-based epidemic model for teaching. Problem: biology students struggle to picture how infection spreads. User: a biology teacher. Complexity: agent objects, probability, adjustable parameters, charts of results. Risk: claiming scientific accuracy; present it as a teaching model and say so in your success criteria.
- Projectile or orbit sandbox. Problem: physics students want to test "what if" scenarios quickly. User: a physics teacher. Complexity: step-by-step numerical updating, OOP bodies, checking output against known results. Risk: the physics getting ahead of your coding; keep to models you can verify.
Algorithms and optimisation
These lean on B2.4 programming algorithms and give Criterion D plenty to talk about.
- Campus or hike route planner. Problem: new students, or a hiking or expedition group, need the quickest or safest route. User: a new-student mentor or an expedition leader. Complexity: a weighted graph and a shortest-path algorithm such as Dijkstra's. Risk: mapping takes forever; keep the graph small and hand-built.
- Exam or class seating planner. Problem: seating plans must keep certain students apart and meet access needs. User: a teacher or exams officer. Complexity: constraint checking, backtracking or a greedy approach with improvement swaps. Risk: personal data; use anonymised or invented names.
- Tournament fixture generator. Problem: a club league needs fair fixtures around venue availability. User: a club organiser. Complexity: round-robin scheduling plus constraints, standings sorted with tie-breakers. Risk: a plain round-robin is too simple on its own; the constraints are what make it an IA.
- Puzzle generator and solver. Problem: a teacher wants logic puzzles at chosen difficulty levels. User: a maths teacher or puzzle club. Complexity: backtracking, checking a puzzle has one solution, grading difficulty. Risk: solver code is everywhere online; anything copied undermines the whole IA.
- Board game with a computer opponent. Problem: a games club wants a practice opponent for a simple strategy game. User: club members. Complexity: game-state objects, rule enforcement, a recursive minimax search. Risk: the guide rules out copied games without major documented changes, so design and code the game logic yourself.
Machine-learning-lite projects
Machine learning is now core content (A4 machine learning fundamentals), and the guide lets you choose any computer science topic. The safest approach is to implement a simple model yourself so the algorithmic thinking is visible. Ask your teacher before committing to this route.
- k-nearest-neighbours book recommender. Problem: students struggle to find their next book. User: a school librarian. Complexity: your own k-NN, a chosen distance measure, a train/test split to measure accuracy. Risk: borrowing history is personal data; use consented or invented data, and expect a small dataset to limit accuracy.
- Feedback classifier for a club. Problem: a club leader wants comments sorted into themes or positive and negative. User: the club leader. Complexity: text cleaning, a hand-written naive Bayes classifier, accuracy testing. Risk: a one-line library call leaves little for Criterion D.
- Sales predictor from simple data. Problem: a café wants to predict busy days. User: the owner. Complexity: data cleaning, linear regression coded from the formulas, error measures. Risk: too little data, and treating correlation as cause; your evaluation should be honest about both.
Tools for a real user
A client is no longer required, but a real user still makes your success criteria easier to write and test.
- Vocabulary trainer with spaced repetition. Problem: a language class forgets vocabulary between lessons. User: a languages teacher. Complexity: a scheduling algorithm for review intervals, persistent progress data, class statistics. Risk: similar tools exist; your Criterion A must say why a custom one is needed.
- Readability checker for worksheets. Problem: teachers cannot easily tell if a text suits a reading age. User: a learning-support coordinator. Complexity: string processing, syllable-counting rules, reading text from files. Risk: heuristic accuracy; test against texts with known levels.
- Volunteer rota builder. Problem: a charity spends hours building shift rotas by hand. User: the volunteer coordinator. Complexity: availability constraints, a fairness rule, a database of shifts. Risk: real people's data, so consent and secure storage come first.
- Practical-results checker for science. Problem: class results contain typos and outliers that spoil the analysis. User: a science teacher. Complexity: CSV parsing, validation rules, outlier detection, summary graphs. Risk: ending up with a worse spreadsheet; the validation and detection logic must be the point.
Common pitfalls to avoid
The new IA has not yet been through a full exam session, so there are no examiner reports for it as of November 2026. These pitfalls follow directly from the criteria and the guide's rules:
- A thin problem. A to-do list or quiz with no real processing gives Criterion D (12 of the 30 marks) nothing to assess.
- Vague success criteria. If they cannot be tested, you cannot write a testing strategy in C or an evaluation in E.
- Design that does not match the product. Update your diagrams and algorithms when the build changes.
- Over-scoping. The 35 recommended hours of class time have to stretch across planning, design, testing, writing and the video, not just coding.
- Going over 2,000 words. Put full code in the appendix and use short, commented excerpts in the documentation.
- A video that narrates instead of shows. Demonstrate every feature and run real tests, including invalid input, within five minutes.
- Undeclared AI use. The IB's guidance on AI in assessment says AI-generated work must be credited in the text and referenced. Your school may set stricter rules, and code you cannot explain will not help you in Criterion D.
- Skipping the ethics. Get consent before you collect data or use anyone's system.
IA checklist
- My teacher has approved the problem and the intended user (if there is one).
- I have checked the idea against the guide's list of inappropriate solutions.
- I have written success criteria that can be measured.
- My product includes algorithms I designed and coded myself, not just library calls or a builder.
- I have consent from anyone involved and written permission for any existing system or data.
- My plan covers planning, design, development, testing and evaluation within about 35 hours.
- My diagrams and pseudocode match the final product.
- My documentation is a single PDF of up to 2,000 words, with the word count on the first page.
- My video is no longer than five minutes and shows full functionality and tests.
- My appendix PDF contains the full source code.
- Any AI use is acknowledged in line with IB and school policy.
Not sure which language to build in? Read Python or Java for IB Computer Science, and revise the programming topics on the IB Computer Science hub.
FAQ
Do I need a client for the new IB CS IA?
No. Summaries of the new guide, including ManageBac's, say a client is no longer required. A real user can still help you write measurable success criteria and test your product properly.
Is the IA different at SL and HL?
The task, criteria, word limit and video are the same at both levels, with 35 recommended hours. Only the weighting differs: 30% of the final grade at SL and 20% at HL.
Which programming language can I use for the IA?
The course itself is taught in Python or Java, and the IA section of the guide does not name a required language. Most students build in the language they are studying so their exam practice and IA reinforce each other, but check what your school expects.
Can I make a game for my IB CS IA?
Yes, the guide lists a computer game as an appropriate type of product. Copied games without major, documented code changes are not acceptable, and the game still needs algorithmic depth, such as a computer opponent or level generation.
Can I use libraries or frameworks?
The guide lists existing libraries among techniques you can use, and you may research them in planning. The product must still show your own algorithmic thinking and code, and you should justify why each library was the right choice.
How much feedback can my teacher give?
The guide allows your teacher to support your planning and development and to read and comment on one draft, without editing it. The next version you hand in is your final version.
If you want help choosing an idea or turning it into strong success criteria, the free revision guides on the IB CS hub are a good place to start. For one-to-one support, see IB Computer Science tutoring, or book a free 1-hour trial lesson.