The 2027 Singapore-Cambridge GCE A-Level H2 Computing examination, syllabus 9569, has two compulsory papers. Paper 1 is a three-hour, 100-mark written examination worth 60%. Paper 2 is a three-hour, 100-mark laptop-based practical worth 40%. The 2027 syllabus is revised, with six modules covering programming, data structures, data and information, networking, security and emerging technologies.
Students must learn more than how to copy Python code that produces an answer on one example. They need to understand the problem being solved, select suitable data and algorithms, implement a robust solution, test it and identify the limitations of the resulting system. Computing also requires judgment about privacy, security and the consequences of technology choices.
- Subject: H2 Computing 9569, revised syllabus first examined in 2027.
- Paper 1: 3 hours, 100 marks, 60%; six to eight structured questions drawing on all six modules.
- Paper 2: 3 hours, 100 marks, 40%; four compulsory practical questions testing modules 1, 2, 3, 4 and 6.
- Practical technologies: Python, HTML, CSS, Flask and SQLite; the approved lab environment also includes JupyterLab, scikit-learn and relevant editing/database tools.
- Major topics: programming fundamentals; data structures and algorithms; data and information; computer networks; social, ethical and security impact; emerging technologies.
- Exam discipline: candidates submit the required saved electronic files, not merely screenshots of a working program.
- Official source: SEAB 2027 H2 Computing 9569 syllabus and SEAB’s 2027 A-Level catalogue.
Information checked 13 November 2026. The syllabus and paper structures are published for 2027. Follow the school’s actual software, lab and administrative instructions; do not assume an installation used in a previous examination year remains the approved setup.
What makes H2 Computing different from knowing how to use a computer?
A person can be very capable with spreadsheets, websites and mobile apps without understanding how software behaves internally. Computing studies the mechanisms: data representation, program control, algorithms, communication between systems and how a design behaves under normal and unusual conditions.
Imagine a programme that records pupils’ attendance. A user may see a simple list of names and checkboxes. The developer must decide how records are identified, how attendance changes are stored, who can edit them, how duplicate records are handled and what happens when a connection fails.
The visible screen is only the interface to a wider system. Sound computing requires reliable logic and careful handling of information, not only attractive design.
Paper 1: a written examination that covers all six modules
The 2027 Paper 1 lasts three hours. It contains six to eight compulsory structured questions and contributes 60% of the overall grade. Students may be asked to explain concepts, trace algorithms, reason about data structures, analyse systems or identify responsible computing choices.
A common preparation mistake is to assume that a strong programmer will automatically score well on theory. Someone may write correct Python but be unable to explain why a particular algorithm has poor worst-case performance, how data travels through a network, or what happens when access control is inadequate.
A good study plan therefore includes conceptual explanations in ordinary language, trace tables, algorithmic diagrams and structured short answers. The goal is to turn practical familiarity into understanding that can be communicated under examination conditions.
Paper 2: a three-hour practical with four compulsory questions
The 2027 lab paper tests students’ ability to implement computing solutions on a laptop. It contains four compulsory questions and contributes 40% of the total qualification. The syllabus explicitly describes practical work involving Python, HTML, CSS, a relational database using SQLite and a local web application using Flask.
The practical paper requires candidates to save and submit the requested electronic files. A program that functions when run in a particular session but whose dependencies, filenames or database are not submitted correctly may not demonstrate the intended solution.
Candidates should practise within the permitted environment and use the school’s official reference guide. Testing only on the student’s personal laptop with unrelated package versions can create a false sense of readiness.
Module 1: programming fundamentals
The first module includes algorithmic ideas and Python programming constructs: sequence, selection, iteration, functions, data types, variables, recursion, validation and error handling.
A student should know when a loop is appropriate and when a conditional is required. They should also understand how a function can isolate a task into a reusable unit, making the program easier to test.
Consider a simple function to calculate admission prices. The input might be age, membership status and the number of tickets. Before writing code, the student must identify which combinations are valid, what discounts apply and whether any rules interact.
If a program accidentally gives a discount twice, the issue is likely the logic, not the Python interpreter. Debugging starts by tracing the decision points and checking which condition was evaluated.
Module 2: data structures and algorithms
The 2027 syllabus includes stacks, queues, linked lists, binary trees, binary search trees, tree traversal, hash tables, searching and sorting algorithms, and object-oriented programming concepts.
These structures exist for a reason. A queue models first-in-first-out processing. A stack models last-in-first-out processing. A hash table can provide efficient lookups under suitable conditions but requires attention to keys and collisions.
Students must understand the operations and trade-offs rather than memorise names. Given a task, what information must be stored? How frequently will records be inserted, searched or deleted? What is the effect of choosing one organisation rather than another?
The syllabus includes insertion sort, bubble sort, quicksort and merge sort, plus linear and binary search, with worst-case time-complexity comparisons using Big-O notation.
Why binary search does not work on any list
Imagine looking for a number in an unsorted list of examination marks. A binary-search procedure assumes an ordering that allows half the search space to be eliminated after each comparison. Without that ordering, eliminating one half may discard the target.
A student who remembers that binary search is “fast” but ignores the sorted-input condition has missed the underlying algorithm.
The better habit is to list preconditions before using an algorithm. What is assumed about the data? What does each step preserve? When does the procedure terminate? What must be returned when the target is absent?
This is a powerful example of why computing requires reasoning rather than code memorisation.
Module 3: data and information
Computers store and process representations of information. The syllabus includes number systems, structured data and topics related to how information is stored and managed.
Students need to distinguish a value from how it is represented. A piece of text that looks like a number may not behave as a numeric value. A database can store many records, but incorrect field choices or relationships can make them difficult to update or interpret reliably.
A useful data example is a school library. Each book title may have many physical copies. Treating a title as a unique identifier for every copy can create ambiguity. A better data design represents the relevant entities separately and makes their relationships explicit.
Students should be able to explain why a chosen schema fits the task, not merely enter records into a table.
SQL and databases: correctness depends on relationships
SQL is used to query and manipulate relational information. The practical examination specifies SQLite. Students should understand the relevant table structure, primary and foreign keys where applicable, and the relationship between a query and the question being asked.
A query can run without error and still be conceptually wrong. For example, joining two tables incorrectly may duplicate rows and produce an inflated count. Filtering by the wrong field may remove valid records.
The repair is to test small examples with known outputs and check record counts before trusting an aggregate. Ask what each result row represents and whether that representation matches the intended task.
An effective database solution should also handle invalid or missing inputs appropriately rather than assuming that every form is completed perfectly.
Module 4: computer networks and web applications
The syllabus includes local and wide area networks, internet architecture, IP addressing, DNS, communication protocols, packet switching and client-server systems.
A web application involves communication between a client and a server. The interface may present a form, while the server validates input, processes a request, stores or retrieves data and returns a result.
In the 2027 practical, students use HTML and CSS for the client and Python with Flask on the local server, with data stored and retrieved through an SQL database.
A good developer can explain which actions belong in the browser, which belong on the server and why sensitive validation cannot rely solely on a visible interface. This understanding also supports responsible security design.
A simple design case: event registration
Suppose a school wants a registration form for a workshop. A minimal design accepts a participant’s name and session preference, checks whether the session exists and records a unique registration.
Before implementing, students should ask:
- What data are actually needed for the event?
- How will a duplicate submission be recognised?
- What happens if the session is full?
- What input types or lengths are acceptable?
- Who can see or edit the registration data?
- What confirmation should be displayed?
- What happens if database storage fails?
A strong solution addresses these questions before polishing the layout. This example is conceptual and should be developed only within authorised school systems using non-sensitive test data.
Module 5: social, ethical and security impact
Computing has social and legal consequences. The 2027 syllabus explicitly addresses confidentiality, integrity and availability, authentication, access control, encryption, checksums, hashes, digital signatures, malware and cyber threats.
It also introduces relevant Singapore legislation and professional responsibilities. Students should learn to recognise the purpose of protections and the consequences of careless handling of personal information.
For example, making an attendance spreadsheet publicly accessible may create an unnecessary privacy risk even if the spreadsheet formulas are perfectly correct.
A good design asks what information is necessary, who legitimately needs access, how it is protected and what happens if the system becomes unavailable.
The syllabus’s treatment of cybersecurity is for defensive understanding and responsible design. Students should not test suspected vulnerabilities on real school or public systems without explicit authorisation.
Module 6: emerging technologies and artificial intelligence
The new syllabus includes emerging technologies, with artificial intelligence among the areas students need to understand. AI can be useful in classification, recommendation and other tasks, but students must understand the difference between a plausible prediction and a reliable conclusion.
A model may perform well on examples similar to its training data yet fail when the data distribution changes. An apparently high accuracy figure can also be misleading when one outcome is much rarer than another.
Students should ask what data were used, which task the model is designed to perform, how success is measured and what errors would matter in the real application.
Using a library such as scikit-learn does not replace understanding these decisions. A functioning model is only one stage in creating a responsible system.
Data validation versus data verification
These terms are frequently confused.
Validation checks whether input meets stated rules or constraints, such as a required format, data type, range or field length. Verification checks whether data have been correctly entered or transferred relative to their intended source.
A form that accepts a plausible date may validate it successfully even when the user entered the wrong date. Validation cannot prove that information is true.
Practise explaining this distinction with real examples. It helps students design accurate software and evaluate claims about data quality.
Testing: normal, boundary and erroneous cases
A program should not be considered finished merely because its first sample input works. The syllabus expects candidates to design tests covering relevant normal, boundary and erroneous conditions.
For a field that accepts quantities from one to ten, a student might check valid values near the centre, the permitted endpoints, and values immediately outside the permitted range. Then inspect whether the response meets the specification.
The purpose is to identify the rule the software implements, not to generate a long list of arbitrary test inputs.
Keep a short test table with input, expected result, actual result and any corrective action. This reveals the student’s thinking and helps avoid the temptation to change code blindly.
The danger of hidden notebook state
In notebook-style programming, a variable may retain a value from an earlier execution even when the visible cells are not run in the intended order. A solution can appear to work in the student’s current session but fail when restarted.
A useful reliability exercise is to restart the notebook or runtime, execute the necessary cells in order, and verify that the program still produces the intended outputs. Save all required files in the specified form.
This habit matters in scientific research and professional computing as well as a lab examination. An output that depends on hidden, unexplained state is difficult to reproduce or trust.
How to organise revision across the six modules
Week 1 — review the registered syllabus. Confirm 9569 and compare recent test results with the six modules. Separate programming mistakes from theory gaps.
Week 2 — Python foundations. Practise clean functions, loops, conditions, recursion and validation, with test cases that expose boundary conditions.
Week 3 — data structures and algorithms. Trace sorting and searching, compare their requirements and practise selecting structures for particular operations.
Week 4 — data and databases. Create small, non-sensitive sample data sets, design relationships, query them and check whether the results answer the intended question.
Week 5 — networks, web applications and security. Connect client and server roles with responsible access and error handling; revise the social and ethical issues.
Week 6 — emerging technologies and exam rehearsal. Complete timed written explanations and practical tasks under the official paper conditions. Check saved files, output, assumptions and error causes.
A six-week example cannot replace the full course, but it can provide structure for targeted revision.
What should students do and avoid?
Do
- Verify that the registered subject is H2 9569.
- Download the 2027 syllabus and reference guide.
- Explain algorithmic preconditions before writing code.
- Learn to trace programs and identify the first incorrect step.
- Practise Python, Flask and SQLite using the approved school environment.
- Test normal, boundary and erroneous cases.
- Save, reopen and inspect submitted files as permitted.
- Consider privacy and security before designing data collection.
Do not
- Use the old examination’s package list without checking the 2027 arrangements.
- Assume the lab paper examines every theory module equally.
- Trust one correct test output as proof of software reliability.
- Copy code whose behaviour the student cannot explain.
- Confuse validation with verification.
- Use real personal data for practice without authorisation.
- Treat AI outputs as automatically factual.
- Forget that written Paper 1 is worth the larger share: 60%.
Computing and future education choices
Computing may interest students who are considering degree programmes in computer science, information systems, software engineering, data science, cybersecurity or related disciplines. These courses vary widely in their mathematical foundations and professional emphases.
Some require strong H2 Mathematics preparation and specific A-Level grades. Others accept different recognised qualifications. Students should inspect actual entry requirements and first-year modules rather than assume H2 Computing alone is an admission ticket.
The subject is also useful outside a computing degree because many careers increasingly depend on reliable data processing, systems reasoning and responsible technology use.
Frequently asked questions
Is H2 Computing Paper 2 worth 60%?
No. The 2027 syllabus allocates 60% to written Paper 1 and 40% to lab Paper 2.
Is 2027 the first examination year of the revised 9569 syllabus?
Yes. SEAB identifies the 2027 revision and the corresponding modules and practical arrangements.
Does the lab paper use Python only?
No. It also involves web technologies and SQLite with Flask, within the specified environment and tasks.
Can I prepare entirely by coding?
No. The written paper covers all six modules and examines concepts, algorithms, data, networking, security and emerging technologies.
Do I need to know advanced AI engineering before JC?
The syllabus defines the required knowledge. Students should focus on the prescribed concepts and the actual assessed work rather than chase unrelated frameworks or tools.
Official sources and further reading
- SEAB 2027 H2 Computing 9569 full syllabus
- SEAB 2027 A-Level subject catalogue and Computing reference guide
- SEAB 2027 private-candidate guidance and listed computing software
- MOE post-secondary education
- eduKate Mathematics Learning System
- Previous: H2 English Language and Linguistics 9508
- Next: H2 Further Mathematics 9649
A skilled Computing student understands not only what a program does today, but also why it works, where it might fail and what evidence would make it trustworthy.