What to know about SEAB Syllabus | H2 Computing 9569 in 2027: Python, Flask, SQLite and AI Lab Paper

What software is used for A-Level H2 Computing 9569 in 2027, and how is its laboratory examination assessed? The official SEAB H2 Computing 9569 syllabus specifies Paper 1 Written, 3 hours, 100 marks and 60%, and Paper 2 Lab-Based, 3 hours, 100 marks and 40%. Both papers are compulsory, with all questions compulsory. Paper 2 has four structured problems and expects candidates to work with Python 3, HTML, CSS, SQLite and the Flask web framework as appropriate. Centres must install Python 3 with Flask, JupyterLab and scikit-learn, along with DB Browser for SQLite and Notepad++. A reference guide is supplied, and the three-hour lab period includes saving the work required for electronic submission.

This is the 2027 A-Level H2 examination, not the 2027 SEC G3 Computing K349 paper, which has a different duration and syllabus. The revised H2 curriculum has six modules: Programming Fundamentals; Data Structures and Algorithms; Data and Information; Computer Networks; Social, Ethical and Security Impact of Computing; and Emerging Technologies. Paper 1 can test all six, while the lab assesses modules 1, 2, 3, 4 and 6. Good preparation teaches a student to define a problem, design a solution, produce working software, test edge cases and reflect on security and ethical consequences—not simply paste a memorised Python program into the examination environment.

• Subject: A-Level H2 Computing 9569, revised syllabus first examined in 2027.
• Paper 1: three hours, 100 marks, 60%, six to eight structured questions across all six modules.
• Paper 2: three hours, 100 marks, 40%, four compulsory lab-based questions; save required softcopy files during the allotted time.
• Software: Python 3, Flask, JupyterLab, scikit-learn, DB Browser for SQLite and Notepad++ in the authorised lab environment.
• Application technologies: HTML/CSS, Python, SQLite databases and Flask may be used as required by the task.
• Provided reference: SEAB programming reference guide; it does not replace independent algorithm design and testing.
• Assessment objectives: roughly 20% knowledge, 40% application, 40% design/development/testing overall.
• First action: verify the correct year and code, then practise a small complete application with a clear specification and test record.

1. H2 9569 is not the same examination as SEC G3 K349

The Singapore-Cambridge A-Level H2 Computing subject is a pre-university qualification. It has its own assessment structure and technological demands. The first Secondary Education Certificate in 2027 uses G1, G2 and G3 levels at secondary school, with Computing entries including G1 K127, G2 K237 and G3 K349. H2 9569 is not a renamed form of K349. A pupil who uses an SEC Computing lab guide as the entire preparation for H2 may miss databases, Flask applications, scikit-learn, advanced algorithms and the separate assessment scheme.

The 2027 H2 syllabus is marked revised. This makes it especially important to use the examination-year document rather than a mixture of old code examples. The official A-Level directory provides specimen Papers 1 and 2 and a Reference Guide for the revised subject. Specimens illustrate demands; they are not advance copies of the live exam. Students should prepare for the underlying concepts and learn the actual tools permitted by their school.

Another cohort distinction matters. A student who takes SEC in 2027 and enters JC in 2028 ordinarily sits A-Levels after 2027. The 2027 H2 Computing PDF is useful for understanding present content, but families must check the later exam-year syllabus when the student’s cohort reaches the A-Levels. Avoid promising that a current application framework or software version can never change.

2. The two-paper scheme and assessment balance

A student who loves coding may focus almost entirely on lab practice. That would ignore the written paper’s sixty-percent contribution. Conversely, a student who memorises definitions and algorithm descriptions may be unable to implement a working solution in Paper 2. The subject requires conceptual knowledge and practical competence. The best learning plan moves between them so that a technique understood in theory can be used appropriately in code.

SEAB’s overall assessment objectives include approximately twenty percent knowledge and understanding, forty percent application, and forty percent designing, developing and testing computing solutions. These categories are related but not identical. A learner can explain what a database is without being able to create a robust query for an application; another may write code that works once but cannot explain why it fails when an input is missing.

3. What happens in the three-hour lab examination?

Paper 2 is a lab-based examination conducted on a laptop provided by the centre. The syllabus requires four structured questions of different lengths and marks. Candidates must create and submit required softcopy work. Saving the files is included within the three-hour allowance. Thus, exam readiness includes correct file handling, not only programming logic. A program displayed on screen may not be correctly submitted if the candidate saves the wrong version or ignores the specified filename.

The centre must provide the stated software. This does not authorise students to bring their own device, install arbitrary plugins or rely on unrestricted internet access. Follow the current school and SEAB candidate instructions for actual permissions. A student who practises exclusively through a cloud-based AI programming assistant may struggle if that service is not part of the authorised exam environment.

Students should practise a self-contained workflow: read the problem, outline inputs and outputs, design the algorithm, implement, run appropriate tests, examine failures and save the required artefacts. The ability to repeat that process on a genuinely new task matters more than repeating one elaborate application until the steps are familiar.

4. Why the official software list matters

SEAB identifies Python 3 and its modules Flask, JupyterLab and scikit-learn; DB Browser for SQLite; and Notepad++ as installed software for the lab. These tools serve different purposes. Python provides general programming capabilities. JupyterLab can support exploration and code development. Flask supports building a web application. SQLite offers a database engine and SQL queries. Notepad++ supports editing files such as HTML and CSS. Scikit-learn provides specified machine-learning tools within the syllabus’s emerging-technology scope.

A student should understand the role of each tool rather than assume a task requires using every program. A simple algorithm question may be solved in plain Python. A data query may use SQLite. A web task may need HTML, CSS and Flask. A machine-learning component may use the provided library as directed. Effective tool choice is itself part of computational thinking.

Software versions and approved syntax may change across examination years. The school should prepare students in the actual environment and explain which tools and imports are allowed for practice. Online documentation may discuss additional features that are interesting but not within the assessed 2027 reference guide. More advanced technology is not automatically more useful for the examination’s specific task.

5. Six modules: a complete conceptual map

Module 1 Programming Fundamentals covers algorithmic construction, functions, data types and program execution. Module 2 Data Structures and Algorithms develops approaches for representing and processing data efficiently. Module 3 Data and Information includes databases and data management. Module 4 Computer Networks concerns communication and network design. Module 5 Social, Ethical and Security Impact explores the consequences and responsibilities of computing. Module 6 Emerging Technologies includes newer applications such as artificial intelligence within the prescribed learning outcomes.

Paper 1 can draw on all six; Paper 2 tests all except the standalone Module 5 in its listed lab coverage, although responsible computing principles still matter in practical implementation. A pupil should not assume that learning Python syntax will cover networking, database modelling or AI ethics sufficiently. These are connected domains, but each has concepts that need deliberate teaching.

One useful way to understand the connections is to imagine a simple school service for registering interest in an activity. The programming module controls input and decisions. A database stores records. A web interface lets authorised users interact with the service. Networking supports communication. Security and ethical thinking govern access and privacy. Emerging technologies might introduce a recommendation feature, which must be evaluated carefully rather than trusted automatically.

6. A program must answer the specified problem

Before writing code, identify the inputs, expected outputs, conditions and constraints. A student asked to return the average of positive scores should not simply divide every sum by the number of entries without checking whether the list is empty or contains invalid values. A program may execute without raising an error and still fail its actual task if it interprets the specification incorrectly.

Use a small original algorithm exercise. A shop records item prices and quantities. The program must calculate the subtotal and reject negative quantities. Ask the pupil to state the rules in ordinary language first. Only then implement and test them. If the teacher later changes the requirement to allow returns, the earlier rejection rule may no longer be appropriate. The program should change because the specification changed, not because a line looks unfamiliar.

This habit is valuable in many fields. A computer can apply a wrong rule perfectly consistently. Responsible programmers first define the rule and the evidence that a correct output would satisfy it.

7. Python functions and modular thinking

Functions break a larger program into smaller units with specified purposes. A good function has clear inputs and outputs and does one understandable job. This improves testing and reuse. A pupil who writes one enormous block of code may find it hard to locate an error or adapt the solution when a new requirement is added.

For an original example, consider a function that calculates a price after a discount: def discounted(price, rate): return price * (1 - rate). The expression assumes the rate is a fraction such as 0.10 for ten percent. It says nothing about whether the price is valid or whether rounding rules apply. Those conditions belong to the problem specification. A student should explain the assumptions before copying the function into an application.

Next ask for tests: price 100, rate 0.1 gives 90; price zero gives zero; rate zero gives the original price. What happens if the rate is larger than one or negative? The expected handling must be specified. A program that works for the familiar first test may still be incomplete. Testing teaches precision.

8. Lists, dictionaries and algorithm choice

Data structures influence how information is accessed and updated. Python lists can represent ordered collections; dictionaries map keys to values. Choosing the appropriate structure helps solve the problem cleanly and may affect efficiency. A student should not use a dictionary simply because it seems advanced if an ordinary list would meet the requirement more clearly.

Suppose a simple activity-registration program needs to look up the attendance status of a student by an authorised identifier. A dictionary can associate the identifier with a status. The exact identifier should be invented in educational examples rather than using real student records. If the program instead processes a sequence of anonymous measurements, a list might be more natural. The structure follows the task.

The syllabus includes algorithmic reasoning and common techniques for processing data. Teach students to explain why the chosen approach works and how it behaves as the input grows. Efficient algorithms are not just fast examples; they are methods whose expected behaviour can be understood under different conditions.

9. Why efficiency and correctness are two different questions

A program may produce correct output but become impractically slow on large inputs. Another may be fast but wrong. H2 Computing develops the ability to reason about data structures and algorithms, including properties of standard algorithms under the syllabus. A learner should understand the trade-off between straightforward implementation and efficient processing when input sizes increase.

Consider an original example: to find whether a name appears in an unsorted list, a simple linear search checks entries until it finds a match or reaches the end. If the list is sorted and the task conditions permit, a binary search may be more efficient by repeatedly narrowing the search range. But binary search on an unsorted list cannot be assumed correct. The precondition matters as much as the algorithm.

Ask the student to describe the sequence of comparisons on a small list and test special cases such as an empty list or a missing target. The intellectual skill is understanding why the algorithm works and when it is appropriate, not memorising code without the necessary assumptions.

10. SQLite: a database is not merely a spreadsheet

Relational databases organise data in tables linked by keys and relationships. SQLite provides a lightweight database engine, and DB Browser for SQLite assists with inspection. H2 Computing candidates may be required to use SQL to create, retrieve or update information in the context of a larger solution. The official reference guide provides specified syntax; students still need to design the correct table structure and queries.

For an original fictional example, a school club stores anonymous event registrations with a registration ID, event ID and attendance status. A table can enforce a unique identifier and represent the relationship between records. A query might retrieve registrations for one event. The relevant concept is how constraints and keys protect the meaning and consistency of the data. This is more sophisticated than simply typing the same entries into separate worksheets.

Use harmless invented records during practice. Students should not use real names, passwords or sensitive information in a public demonstration. Responsible data handling includes collecting only necessary fields and understanding which users should be able to read or change them.

11. SQL queries: read the meaning before trusting the result

A SQL query can return a tidy table while answering the wrong question. Imagine asking for registrations where the event ID equals a particular value. If the student filters on the wrong column, the database may still produce rows, creating false confidence. The learner must understand what the query selects, which fields identify a record and whether the returned result matches the specification.

For a simple original query, SELECT event_id, COUNT(*) FROM registrations GROUP BY event_id; groups records by event ID and counts rows per event, assuming a suitable table named registrations. But the count means only what the stored rows represent; if some registrations are cancelled or duplicated, the answer may not equal actual attendance. A good explanation identifies the data’s meaning and limitations.

Test queries with small controlled datasets before using them in a larger Flask application. Verify empty-result cases, duplicates and joins where relevant. A correct database result depends on both the SQL syntax and the underlying data model.

12. Flask and HTML/CSS: a web application is more than a displayed page

The 2027 Paper 2 includes web development with Python and Flask alongside HTML and CSS. HTML describes document structure, CSS controls presentation, and Flask connects web requests to application logic in Python. Students need to understand how user input reaches the program and how an appropriate response is produced. A page that looks attractive but does not process the required input is not a complete computing solution.

Consider a simple fictional book-recommendation service. An HTML form allows a user to choose a genre. Flask receives the request and uses a Python function to select a result from a small authorised dataset. The application returns a page describing the recommendation. To meet a real problem specification, the student must handle missing input, avoid exposing personal information and test that the result matches the chosen genre.

Do not assume an examination will ask for this exact application. The value of the illustration is to connect the roles of the components. The learner should be able to build a new solution when the scenario changes, such as a library registration or event schedule, without relying on a single copied project.

13. Input validation and safe application design

A web application receives information from users, which may be missing, unexpected or incorrectly formatted. Input validation checks whether it meets the intended rules before it affects the system. A form asking for a number of attendees should not silently interpret arbitrary text as a valid number. A database query should use appropriate safe handling of supplied input rather than create a query by blindly joining untrusted strings.

Security is not separate from correctness. If a program stores passwords or private records insecurely, it may appear to work while creating real risk. Students should understand the ethical and security implications of computing within the syllabus, including the principle of limiting access to necessary data.

All practice should remain within authorised systems and harmless datasets. The purpose is to create robust, trustworthy software, not to explore other people’s accounts or networks. A well-designed exam solution can be tested without touching any external system.

14. Networking: connect protocols, addressing and applications

The Computer Networks module concerns how machines and services communicate. A student should understand the difference between a local network, broader communication and the roles played by relevant protocols and services. A Flask web application may run on a local test environment, but that does not mean all its data or services are publicly accessible on the internet. Network context matters.

For an original example, a browser sends a request to an application. The application may retrieve information from a local SQLite database and return a response. These are distinct operations, even if the user sees only one webpage. Ask what happens when the server is unavailable, an address is wrong or a response is delayed. The learner should connect the observed failure with the component that may be responsible.

Network understanding helps students debug applications and think responsibly about access. It is also valuable for everyday digital literacy: a device’s ability to connect is not proof that every online service is trustworthy or secure.

15. Emerging technologies: scikit-learn, models and their limits

SEAB includes Emerging Technologies as Module 6, and the centre must install scikit-learn as part of its Python environment. The syllabus’s prescribed outcomes cover appropriate artificial intelligence and machine-learning concepts. Students should understand what a model is designed to do, what data it uses, how performance is evaluated and what limitations may arise. They should not treat a predicted label as an unquestionable truth.

Consider a fictional model that categorises anonymous sensor readings into groups. Its output may be useful for recognising patterns, but it depends on the training data, features and assumptions. If the real environment differs from the training examples, predictions may be unreliable. Students should test with appropriate held-out cases and avoid claiming general accuracy from the same examples used to build the model.

Machine learning also raises questions of bias and privacy. If an educational system makes recommendations using incomplete data, the absence of information about a person should not be interpreted as evidence of low ability or interest. Responsible computing requires thinking about who could be affected by a model’s errors.

16. The Social, Ethical and Security Impact module

The fifth module concerns social, ethical and security implications. It is assessed in Paper 1, while the lab’s module coverage is listed separately. This does not make the topic optional or unimportant. Students should consider the responsibilities associated with designing and using information systems, including cybersecurity, fairness, privacy, accountability and intellectual property.

A public-facing application that collects more information than needed may create risk without improving service. A recommendation algorithm can unintentionally disadvantage people absent from a dataset. An apparently helpful automated decision may be difficult to challenge if nobody can explain its basis. These are practical questions about real users, not abstract essay decoration.

Teach pupils to connect technical choices with consequences. If an application requires an account, what information is strictly necessary? Who can access the records? What happens if the system returns an incorrect result? Such questions turn ethical awareness into better software design.

17. Test cases: the difference between running once and working reliably

A successful demonstration using one sample input does not establish program correctness. Testing should include ordinary cases, boundary values, missing or unsuitable inputs and relevant larger datasets. A clear test plan records the input, expected behaviour, observed behaviour and any discrepancy. The goal is to expose weaknesses before final submission, not to create a long decorative list of tests.

Suppose a function counts students registered for an event. Test zero registrations, one registration, multiple registrations and cancelled entries if cancellation is part of the task. The expected result depends on the specification. If the function counts every row but the question asks for active registrations only, the program may run correctly according to its code while answering the wrong question.

When an error occurs, locate the first incorrect assumption. Did the code interpret a string as a number, use an incorrect condition, or query an unexpected table? Fix the cause, then rerun the relevant test and another nearby case. This is far more reliable than changing random lines until the display looks plausible.

18. File saving, version control and submission

Paper 2 requires softcopy submissions, and the examination time includes saving files. A candidate may have built the correct application but accidentally save an earlier file or omit a dependency. School practice should therefore include a final verification step: what files are requested, where do they belong, and can the saved version be opened or run appropriately within the authorised environment?

Version control can be taught simply. Keep clear practice folders and avoid overwriting the only working copy without deliberate reason. After a change, run the most relevant tests. Students should not assume that an online repository or external file transfer is authorised in the national examination; follow centre instructions.

These habits are useful beyond assessment. Software development in workplaces depends on reproducible results, clear communication and careful handling of changes. A student who learns them early becomes more capable of maintaining complex work.

19. Managing the three-hour lab without guessing the exact questions

With four compulsory questions in three hours, candidates need to read the task requirements and plan their work. Some problems may be more demanding than others. The syllabus does not provide a guarantee that the questions will resemble a specific online tutorial, so students should practise unfamiliar tasks aligned with the current modules and reference guide.

A useful general routine is to identify deliverables, sketch the core algorithm or data model, implement a simple working version, test it and then refine. This prevents spending the full period on visual polish while a required database or calculation remains incomplete. But the actual distribution of time should follow the marks and complexity of the live paper, not a fixed schedule invented in advance.

Students should also understand the paper’s saved-file requirements through school practice. A short final review can catch incorrect filenames, an outdated version or missing outputs. Calm preparation builds the habit before the examination rather than relying on last-minute memory.

20. Does secondary Computing guarantee H2 Computing readiness?

A student may have taken G3 Computing at SEC, participated in a coding club or learnt Python independently. Those experiences can provide helpful foundations, but H2 Computing has broader demands and the particular JC sets its own subject allocation policy. A learner without the exact secondary subject may still have transferable problem-solving skills, but should confirm actual prerequisites with the receiving school.

Check whether the student can reason about algorithms, data structures and basic programming independently, not merely follow tutorials. H2 adds database systems, web applications, computational models and deeper evaluation. A strong motivation to study computer science is valuable, but it should be paired with an honest assessment of the mathematical and computational skills needed.

University admission is a separate question. Completing H2 Computing does not automatically satisfy every computer-science degree’s subject prerequisites or guarantee admission. Consult the institution’s current course entry information rather than assuming one named H2 subject settles the decision.

21. Twelve preparation errors worth correcting

1. Confusing H2 9569 with SEC G3 K349 or new G2 K237.
2. Using an older H2 syllabus without checking the revised 2027 reference.
3. Ignoring Paper 1 even though it is worth sixty percent.
4. Practising only Python syntax while neglecting databases, networking, security or AI concepts.
5. Assuming candidates may install any external library or use unrestricted internet services.
6. Creating attractive HTML pages without a working application behind them.
7. Writing SQL queries before understanding the underlying data relationships.
8. Testing a program only on the example provided in the question.
9. Ignoring empty inputs and boundary conditions when the specification makes them relevant.
10. Assuming a machine-learning model is correct because it predicts its training examples.
11. Saving the wrong version or omitting required files during the lab.
12. Confusing a successful demonstration with a complete, robust and appropriately secure solution.

Each error points to a teachable mechanism. A learner who misreads requirements needs specification practice. A student whose SQL query returns the wrong rows needs data-modelling work. A pupil who produces an unreliable Flask application needs testing and validation. Extra hours help only when they address the actual weakness.

22. Three illustrative computing learning cases

Case A: Python fluency, weak data modelling

A JC student can write loops and functions but repeatedly joins the wrong database tables. The teacher returns to keys and relationships, using a small fictional dataset. The learner sketches the schema and explains what each table represents before writing SQL. After practice, a new query becomes easier because the underlying model is clearer.

Case B: web application looks good but accepts invalid input

Another pupil builds a polished HTML interface and a working Flask route. However, an empty form produces an error, while a negative quantity creates an impossible result. The tutor asks the student to define valid inputs, handle missing values and record expected outputs. Testing reveals which assumptions were missing. The improvement is in reliability, not appearance.

Case C: machine-learning results without evaluation

A student trains a model and reports its score on the same examples used for training, then claims it will work on new data. The teacher introduces a held-out test concept and discusses representativeness. The pupil learns why performance evidence needs appropriate separation and why fairness must be considered. A stronger model argument follows from better evidence.

23. A four-week H2 Computing revision plan

Week 1 — verify, map and diagnose

Download the official 9569 PDF and the SEAB reference guide. Record the two-paper weightings, software list and module coverage. Use short independent tasks in algorithms, SQL, Python web basics and theoretical reasoning. Identify the first recurring error, such as misunderstanding a requirement or failing to test a boundary case.

Week 2 — repair a core computational mechanism

Choose the weakest foundational area. For algorithms, practise decomposition and control flow; for databases, sketch relationships and keys; for Python, write small functions and test them. Use one worked example followed by an unfamiliar independent attempt. Keep the environment aligned with school guidance rather than relying on arbitrary online packages.

Week 3 — integrate a small end-to-end application

Use invented non-sensitive data to build a simple task involving HTML/CSS, Python and an SQLite database where relevant. Define what the application should do, test normal and edge cases and save the correct files. Include a short discussion of what data the application should collect and how errors or unauthorised access should be prevented.

Week 4 — practise unfamiliar problems and balance theory

Try fresh problems drawn from the 2027 scope, using appropriate timed practice. Review how the learner interpreted the brief, chose the tools, checked the result and handled submission files. Include Paper 1 topics such as networks and ethical impacts. Adjust the study plan and preserve time for other JC subjects and rest.

24. Frequently asked questions

What is the official 2027 H2 Computing subject code?

9569. The 2027 A-Level Computing syllabus is marked revised and first examined in that year.

How many papers does H2 Computing have?

Two compulsory three-hour papers. Paper 1 is 100 marks and 60%; Paper 2 is 100 marks and 40%.

What is the H2 lab paper’s structure?

Four compulsory structured questions completed on the authorised laptop, with saved softcopy work submitted for marking.

Is Flask part of the 2027 syllabus?

Yes. SEAB specifies Python and the Flask web application framework, alongside HTML, CSS and SQLite, for appropriate lab tasks.

Does the centre provide scikit-learn?

The official syllabus lists Python 3 with Flask, JupyterLab and scikit-learn as software required on examination laptops.

Is DB Browser for SQLite installed?

Yes, as part of the centre software specification, alongside Notepad++.

Can candidates use their own laptops?

Do not assume so. The syllabus requires the centre to provide examination laptops and the approved environment; follow the current centre instructions.

Is the three-hour duration inclusive of saving files?

Yes. SEAB specifies that the allotted time includes saving the required work on the examination laptop.

Are all six modules tested in Paper 2?

No. Paper 2 is listed as covering modules 1, 2, 3, 4 and 6, while Paper 1 can test all six.

Is a programming reference guide provided?

Yes. Candidates receive the official reference guide for lab Paper 2. It assists with syntax and permitted tools but does not design or test solutions for them.

Are calculators allowed?

An approved calculator is permitted for both papers, according to the 2027 syllabus.

Is H2 Computing the same as G3 Computing?

No. The former is pre-university A-Level 9569; the latter is secondary SEC G3 K349, with different subject content and examinations.

Does a Computing grade guarantee entry to a computer-science degree?

No. University admission depends on the receiving programme’s actual subject requirements and selection rules. Check the intended institution.

25. Official sources and further eduKate reading

Official, checked 7 November 2026: SEAB 2027 A-Level H2 Computing 9569 syllabus, module and laboratory requirements; 2027 A-Level school-candidate directory, specimens and reference guide. The code and database examples above are original educational illustrations, not reproduced exam content.

Related eduKate guides: A-Level Computing 9569 scope and modules; H2 Computing and future degree planning; SEC G3 Computing K349 compared; G2 Computing K237 introduction.

Computing is most valuable when a student can understand a problem, build a solution that meets the real requirements and explain how they know it works. The lab assesses those abilities in software; the theory paper connects them with the technologies and responsibilities that shape everyday life.