VIEW THIS AS

Auto mode follows the Route Engine until you choose a viewpoint.

YOU ARE HERE

ROUTE CHECK

CONNECTED TO

WHAT NEXT

Use the canonical route for this room, or HELP if you are unsure.

Ultimate Secondary 4 PG3 Computing Syllabus Guide | Prepare and Master the Latest SEC FSBB

For Secondary 4 students who entered secondary school through Posting Group 3, the first step is to verify the exact SEC Computing subject and G level. PG3 describes the school posting route; it does not itself name a national Computing paper. The first Singapore-Cambridge Secondary Education Certificate (SEC) begins in 2027, with G3 Computing using SEAB syllabus K349 (previous reference 7155). It has a two-hour written Paper 1 worth 60% and a two-hour-thirty-minute computer-based practical Paper 2 worth 40%. The subject covers computing fundamentals, algorithms and Python programming, spreadsheets, networking, and the impact of computing. This guide explains what parents can check and how students can prepare without buying unnecessary technology.

The most useful first action is to ask the school to confirm K349, check the actual Python, spreadsheet and JupyterLab software used for instruction, and review one marked written paper plus a lab task saved by the child. Find the first barrier: binary and logic, selecting an algorithm, tracing program state, validating inputs, fixing Python syntax, interpreting spreadsheet formulas or submitting files properly. Paper 1 has compulsory questions across all five modules; Paper 2 has one spreadsheet task and four to five programming questions, all compulsory. The first SEC is in 2027; students graduating in 2026 follow the previous examinations. Progress is shown by the student’s working solution and explanation, not merely by a large number of lines of code.

  • PG3 is a posting route. G3 Computing K349 is an examination subject—confirm its code rather than assuming the timetable labels establish the entry.
  • Paper 1: two-hour written paper, 80 marks, 60%; multiple choice, matching, cloze, short-answer and structured tasks across all five modules.
  • Paper 2: 2 h 30 min computer-lab examination, 70 marks, 40%; one spreadsheet question and four to five Python programming questions.
  • Paper 2 requires submitting saved digital work. Its allocated time includes saving files, so practise final file checks.
  • Five modules: Computing Fundamentals; Algorithms and Programming; Spreadsheets; Networking; Impact of Computing.
  • Prepare by analysing requirements, coding, tracing, testing edge cases, explaining data, and reviewing security and ethics.
  • Use school-confirmed software and safe practice, and check the new 2028 post-secondary admissions rules for the SEC cohort.

1. Why PG3 and G3 Computing must not be conflated

Full Subject-Based Banding allows students to offer different subjects at suitable G levels under the relevant school and MOE criteria. The earlier Posting Group does not dictate the student’s Computing examination level. G3 Computing K349 is distinct from the new G1 Computing K127 and G2 Computing K237, which have different syllabuses and assumptions. Ask the school whether the learner is registered for K349 and which software environment is used; online ‘Singapore Computing’ tutorials may follow quite different programming languages or specifications.

SEAB says the SEC combines the former separate N(T), N(A) and O-Level qualifications from 2027 without changing overall examination standards. Use the official 2027 G3 Computing K349 syllabus, the G3 syllabus directory and the school’s instructions for lab work. The syllabus itself identifies the five learning modules and the software required for the lab. Fancy artificial-intelligence tools, unrelated web frameworks or advanced programming contests are not automatically part of K349.

2. Correct paper scheme for 2027

Paper Time Marks / weight Requirements
1 Written 2 hours 80 marks / 60% All compulsory questions across the five modules; mixed multiple-choice, short answer, matching, cloze and structured responses.
2 Lab-based 2 h 30 min 70 marks / 40% All compulsory: one spreadsheet task and four to five programming tasks using a computer with spreadsheet, Python and JupyterLab.

Paper 2 includes the time needed to save the softcopy deliverables for marking. The school or examination centre provides a computer and the relevant software for the examination. A Python quick-reference guide is provided in the practical. Paper 1 has formulae as specified. An approved calculator may be used for both papers, though this does not replace understanding binary arithmetic, algorithms or spreadsheet logic. Students should practise the actual workflow prescribed by the school rather than assuming an arbitrary online coding platform is equivalent.

SEAB’s approximate overall assessment-objective balance is 30% knowledge and understanding, 40% application and 30% designing, developing, testing and refining computing solutions. Computing therefore requires a different study habit from passive video viewing: the learner must write and test a solution, find what is wrong, and explain why the corrected version handles normal, error and boundary cases.

3. Diagnose the exact Computing problem

Ask for one short Python program written by the student and a separate spreadsheet they created. Do not ask only whether the code runs: identify the task requirements, what the program outputs, which cases it fails and how the child tested it. In a written question, determine whether the student is weak in bits and bytes, logic gates, computing hardware, networking concepts or ethical reasoning. In the lab, look for misunderstandings of loops, conditionals, data types, formulas, relative references or file handling.

Use an error log with four columns: expected output, observed output, likely cause and corrected test. A learner who can explain a solution after watching someone else type it may not yet be independent. Ask them to reproduce the approach for a different set of input values without opening the model code. Parents do not have to be programmers to request a working demonstration and check the expected examples.

1. Computer architecture

Processors, main memory and secondary storage have different responsibilities. A fast computer does not make a poorly designed algorithm correct.

Original illustration: Original case: restarting a device may remove data held only in volatile memory while a saved file remains in non-volatile storage.

Parent’s next action: Ask the learner to explain where a value is held while running and how it persists after saving.

2. Storage units

Bits and bytes differ by a factor of eight, and decimal and binary multiples should not be confused.

Original illustration: Original case: 1,024 bytes equals one kibibyte, while a kilobyte convention often uses 1,000 bytes; name the unit instead of silently switching.

Parent’s next action: Have the student state the convention used before calculating a capacity.

3. Binary numbers

Binary positional value represents integers with powers of two. A calculation must not treat the digits as decimal ones and tens.

Original illustration: Original example: binary 101101 means 32 + 8 + 4 + 1 = 45 in decimal.

Parent’s next action: Ask why the positions represent powers of two, then test a different binary number.

4. Hexadecimal conversion

Hexadecimal groups bits conveniently; each hex digit corresponds to four bits. Conversion is a representation change, not encryption.

Original illustration: Original example: binary 1111 0010 corresponds to hexadecimal F2, or decimal 242.

Parent’s next action: Have the learner show the two groups and check the resulting decimal value.

5. Two’s complement

Negative integers can be represented in a fixed-width two’s-complement form. The width affects the range of values representable.

Original illustration: Original example: in eight bits, −5 is 11111011, obtained from +5 by inversion and adding one.

Parent’s next action: Ask the student to interpret the most significant bit in context and explain why bit width matters.

6. Character encoding

Numbers can represent text characters. Understanding that mapping helps students see why computers store different kinds of information as bits.

Original illustration: Original example: a letter can be associated with an encoding code, whereas the underlying stored pattern remains binary.

Parent’s next action: Ask the learner to distinguish character encoding from encryption and compression.

7. Logic gates

AND, OR, NOT, NAND, NOR and XOR have defined truth tables. Logic circuits follow these operations rather than guesses from their names.

Original illustration: Original example: XOR is true when exactly one of two Boolean inputs is true.

Parent’s next action: Request a four-row truth table rather than a remembered phrase alone.

8. Boolean equivalence

De Morgan’s laws and algebraic properties can transform conditions while preserving logic.

Original illustration: Original equivalence: NOT(A AND B) is the same as (NOT A) OR (NOT B).

Parent’s next action: Ask the student to prove the equivalence with a truth table.

9. Problem abstraction

A good program specification separates relevant requirements from decorative story details. Define input types, valid values and outputs before coding.

Original illustration: Original task: a school wants to calculate a bill with quantity and price; the program needs those inputs, not the brand of the shop’s chairs.

Parent’s next action: Ask what the program must know and what can safely be ignored.

10. Decomposition

A large task can be broken into smaller transformations that are independently testable.

Original illustration: Original application: reading a list of scores, validating entries, computing an average and formatting a report are separate steps.

Parent’s next action: Have the student describe what each step receives and returns.

11. Flowcharts

Flowcharts illustrate sequence, selection and iteration. Students must follow control flow precisely, including branches that do not execute.

Original illustration: Original case: a loop repeats while the count is below five; trace how the count changes on each iteration.

Parent’s next action: Ask for a step-by-step trace of two different input values.

12. Python variables

Variables store references to values in a running program. Assignment updates program state, not an algebraic identity.

Original illustration: Original code idea: total = total + 1 increases the current value by one; it is not an impossible equation.

Parent’s next action: Ask the child to state the value before and after the assignment.

13. Data types

Strings, integers, floats, lists, dictionaries and Boolean values support different operations. Choosing the wrong type creates subtle bugs.

Original illustration: Original example: text ’12’ joined with ‘3’ may give ‘123’, while integers 12 and 3 add to 15.

Parent’s next action: Ask what type each input has and whether conversion is required.

14. Input validation

A useful program should handle missing, out-of-range or malformed input as specified by the problem. Not every invalid value should produce a cryptic crash.

Original illustration: Original example: a score restricted to 0–100 needs a range check; a blank name may need a presence check.

Parent’s next action: Ask which invalid entries could occur and what the application should do.

15. If, elif and else

Selection chooses a branch based on conditions. Order matters when conditions overlap.

Original illustration: Original example: when a grade threshold is tested, check the higher threshold first if the lower test would also match.

Parent’s next action: Have the student trace values exactly at the boundary.

16. For loops

Iteration over a known range must consider inclusive and exclusive endpoints in Python.

Original illustration: Original illustration: range(1, 5) produces 1, 2, 3 and 4—not 5.

Parent’s next action: Ask the child to list the values before predicting the output.

17. While loops

A while loop can continue indefinitely if its stopping condition is never reached. Its variables and termination matter.

Original illustration: Original case: a counter must change during each iteration if the loop’s condition depends on that counter.

Parent’s next action: Ask what would make the loop stop, and how the program can handle unexpected inputs.

18. String methods

Indexing, slicing and simple string operations enable input processing. Python begins indexing strings at zero.

Original illustration: Original example: ‘school'[0] is ‘s’, while ‘school'[1:4] is ‘cho’.

Parent’s next action: Have the child mark positions under the characters before running the program.

19. Lists

A list stores an ordered collection and allows item lookup, iteration and calculation. Out-of-range positions cause errors.

Original illustration: Original example: scores = [10, 20, 30]; scores[2] is 30, but scores[3] is outside the list.

Parent’s next action: Ask which index range is valid and how length is determined.

20. Dictionaries

Dictionaries map keys to values, suitable for labeled information. Missing keys should be anticipated.

Original illustration: Original example: a dictionary can map student ID labels to submitted scores, but the choice of keys must be unique.

Parent’s next action: Ask what key identifies a record and whether it exists before lookup.

21. Functions

Functions isolate reusable behavior and may receive parameters and return results. Printed output is not automatically the same as a return value.

Original illustration: Original example: a function that computes an average should return a number if another calculation must use it.

Parent’s next action: Ask the learner to show input, computation, return and a sample call.

22. Local and global scope

Variable scope controls where names can be used. Global state may be convenient but can make debugging harder.

Original illustration: Original case: a local subtotal in one function need not be available in another function unless passed or returned.

Parent’s next action: Ask why a particular name is defined and where it should be read.

23. Trace tables

A manual trace follows variable changes line by line and can reveal bugs without running code.

Original illustration: Original example: sum 1 through 4 by updating total from 0 to 1, 3, 6 and 10.

Parent’s next action: Ask the child to write the variable values after each loop iteration.

24. Testing normal cases

A program that works for the example might still fail for ordinary alternative inputs. Choose multiple valid tests.

Original illustration: Original case: test a discount calculation with a low price, a large price and a zero discount as appropriate.

Parent’s next action: Require predicted output before running each test.

25. Boundary and error cases

Boundary cases reveal off-by-one mistakes, while error cases test input validation. A program should meet the specific requirement rather than merely avoid all crashes.

Original illustration: Original case: for ages allowed from 13 through 18, test 12, 13, 18 and 19.

Parent’s next action: Ask the student what each test is intended to prove.

26. Syntax versus logic errors

Syntax errors prevent the program from being parsed, whereas logic errors may produce wrong but plausible results. Run-time errors happen during execution.

Original illustration: Original example: using a misspelled variable name may cause an exception; using the wrong comparison may silently select the wrong branch.

Parent’s next action: Ask what error category the observed behavior belongs to before editing.

27. Incremental debugging

Change one small part, rerun relevant tests and check whether the behavior improved. Randomly rewriting multiple sections can hide the original issue.

Original illustration: Original case: replace an incorrect range endpoint, then rerun the boundary test before changing the output format.

Parent’s next action: Use the error log to identify the smallest justified correction.

28. Spreadsheet cell references

Relative references change when copied; absolute references remain fixed. Students need to understand which reference represents an unchanging rate.

Original illustration: Original example: =$B$1*C2 multiplies a fixed value at B1 by the value in C2, and can be copied downward.

Parent’s next action: Have the learner predict what changes in the formula after copying to the next row.

29. Spreadsheet functions

A function returns a result according to its arguments. SUM, COUNT and AVERAGE are different operations and should not be chosen by appearance.

Original illustration: Original formula: =SUM(B2:B6) adds all numeric values in that range; =AVERAGE(B2:B6) computes their average.

Parent’s next action: Ask what happens if a cell is blank or contains text under the applicable function.

30. Spreadsheet data preparation

Incorrect column types, duplicate records or missing values can corrupt a seemingly impressive chart. Data integrity matters before presentation.

Original illustration: Original case: ’12’ stored as text in one row may be handled differently from numeric 12 in a calculation.

Parent’s next action: Ask what data validation or cleaning is needed before making a claim.

31. Spreadsheet chart interpretation

A chart’s type, units, sorting and axis settings affect what a reader concludes. The chart cannot repair a wrong data source.

Original illustration: Original case: a truncated vertical axis can exaggerate a small change in monthly counts.

Parent’s next action: Ask the student to describe the data’s actual values before the visual message.

32. Network concepts

Networks enable devices to exchange data using protocols and addressing. Distinguish a physical device, a network service and a route taken by traffic.

Original illustration: Original case: a local file transfer and remote cloud upload rely on different infrastructure and risks.

Parent’s next action: Ask what devices must connect and which service handles the requested data.

33. IP and addressing

An address identifies a communication endpoint under a networking scheme; it does not tell a user whether an application is safe.

Original illustration: Original case: two devices on a network require compatible network settings to exchange data using the relevant protocols.

Parent’s next action: Ask which layer of the communication problem is being diagnosed.

34. Network security

Privacy, access control, encryption and safe use matter. Security is not accomplished merely by using a long password if data are shared carelessly.

Original illustration: Original case: a spreadsheet with classmates’ private data should not be posted publicly for practice.

Parent’s next action: Ask whose data are involved, what permission exists and what minimal access is needed.

35. Social and ethical impact

Computing systems can affect work, access, bias, privacy, sustainability and responsibility. Students should analyse mechanisms rather than repeat pro- or anti-technology slogans.

Original illustration: Original case: an automated ranking may disadvantage an underrepresented group if its training data do not reflect the population served.

Parent’s next action: Ask what the decision uses, who is affected and how outcomes could be checked.

36. AI as a learning aid

An AI coding assistant may suggest solutions, but generated code can be wrong or unsuitable for the syllabus. Students should understand every line they submit independently.

Original illustration: Original case: a tool generates a library the exam environment does not provide; the student must replace it with syllabus-allowed Python constructs.

Parent’s next action: Ask the learner to explain and test the solution without relying on the generated answer.

37. Saving and submitting digital work

The exam allocates time for saving softcopy files. A perfect program that is not saved in the required format or location may fail assessment requirements.

Original illustration: Original practice: save a spreadsheet and a script, close them, reopen both and run a quick check before considering the task done.

Parent’s next action: Have the student rehearse a final file-name, folder and submission checklist using school instructions.

4. Three worked tasks that reveal real understanding

Task A: a Python total with trace and boundaries

Suppose an original practice program should add the numbers 1, 2, 3 and 4. The learner can initialise total to zero, loop over range(1, 5) and add each number. The trace is 0, 1, 3, 6, 10 after successive updates. The important explanation is that range excludes its upper limit; changing it to range(1, 4) would omit 4. Have the child predict the output before running the script, then explain why a final result of 10 is correct.

Extend the task by asking for the sum of numbers from 1 through a valid positive integer n. The learner must validate the input, choose an inclusive endpoint carefully, and test n=1, n=2 and a larger normal value. A tutor who types this for the child has produced a demonstration, not evidence of student mastery. The child should be able to re-create it independently with a different requirement.

Task B: a spreadsheet with fixed and changing references

Imagine a class records quantities in cells C2:C6 and a fixed unit price in B1. Each row’s cost can be calculated as =$B$1*C2, copied down so B1 stays fixed while C2 becomes C3 and so on. The student should explain why making both references absolute would be wrong for the repeated row calculation. Then use a SUM function to total the calculated costs and check one row by mental arithmetic.

Next, suppose the quantity column contains a blank or invalid text entry. The learner should identify the input and decide how the spreadsheet should handle it according to the task. A polished chart or neat borders do not prove data correctness. The point of the task is to connect formula structure, data validation and interpretation.

Task C: a small truth-table model

A fictional door alert activates when the door is open AND the building is armed. Let D indicate open and A indicate armed. The expression D AND A is true only when both inputs are true. List all four combinations (false/false, false/true, true/false, true/true) and check the result for each. Then compare it with D OR A, which produces a different behavior. A parent can inspect the completed table without knowing the symbols of every logic gate.

5. The twelve-week preparation plan

Week 1: check code and software

Verify K349 and the software environment with the school. Read a marked written task and inspect a saved programming/spreadsheet submission. Record two concept gaps and one lab-workflow issue.

Week 2: binary, units and logic

Practise bits, bytes, number-base conversions, two’s complement and Boolean truth tables. Ask for written reasoning and unfamiliar data rather than memorised numbers.

Week 3: problem analysis

Turn a real-world prompt into inputs, valid ranges, output and a step-by-step algorithm. Draw one clear flowchart and trace it manually.

Week 4: Python fundamentals

Practise data types, assignments, input and output, strings and arithmetic. Run short tasks the child can reproduce without assistance.

Week 5: selection and iteration

Use if/elif/else and for/while with boundary tests. Train the learner to identify why loops finish and how off-by-one mistakes occur.

Week 6: collections and functions

Practise lists, dictionaries, indexing and user-defined functions. Distinguish print from return and check data types across each step.

Week 7: testing and debugging

Write test cases for normal, error and boundary values, use trace tables, and identify syntax, logic and run-time errors. Retest a repaired bug with a new case.

Week 8: spreadsheets

Work with relative and absolute references, formulas, functions, validated data and charts. Save and reopen files as part of the practice routine.

Week 9: networks and ethics

Review network concepts and security, data privacy, computing’s impact on people, and evidence-based discussion of technology. Avoid broad unverified claims about AI.

Week 10: integrated practicals

Combine one spreadsheet task with several short Python programs. Ask the learner to plan, code, test, correct and save all files using the school’s approved instructions.

Week 11: timed representative papers

Practise a timed written section and lab-based sequence at the official pacing. Check that every compulsory task was addressed and files are saved correctly.

Week 12: consolidate and protect readiness

Retest the most frequent conceptual errors, rehearse the submission checklist and confirm school exam logistics. Maintain rest and time for other subjects.

6. What a parent can do without becoming a programmer

Ask the child to demonstrate their program using two different inputs and to explain each significant line. If it fails, ask what it was expected to do, what happened and which test exposes the issue. That conversation encourages accountability and reasoning without requiring a parent to write Python. Avoid taking over the keyboard, buying an expensive new laptop without consulting the school or installing tools that differ from the examination environment.

A good tutor diagnoses whether the gap is theoretical understanding, program design, syntax, debugging, spreadsheets or exam workflow, then asks for an independent working solution. Claims of guaranteed examination questions or automatic grades are not credible. Keep coding practice balanced with sleep, CCA and the rest of the SEC schedule; a thoughtful short program with proper tests may teach more than hours of copying someone else’s project.

7. Computing and future study options

K349 can help students explore software development, cybersecurity, data analytics and other technology disciplines, but one school subject does not determine career success or guarantee access to a diploma. Academic admission depends on the full SEC profile, the programme’s course requirements and the student’s interests and learning strengths. Responsible computing also includes privacy, security and social effects, which matter in nearly every field.

For students graduating in 2027, MOE has announced the new Post-Secondary Admissions Exercise for 2028. JC, MI, polytechnic and ITE options depend on the current subject-level and course criteria; parents should not infer an admission pathway from one predicted Computing grade. Read MOE's 2026 announcement and the later official application guidance.

8. Useful eduKate learning resources

9. Frequently asked questions

Does PG3 automatically mean G3 Computing?

No. Posting Group 3 is the original entry route. G3 Computing for the 2027 SEC is K349 and should be confirmed on the student’s school record.

What are the two paper weights?

Paper 1 is 80 marks, 60%, two hours. Paper 2 is 70 marks, 40%, two hours thirty minutes. All questions are compulsory in both papers.

Does the practical test only Python?

No. Paper 2 includes one spreadsheet question and four to five programming questions. Both are assessed and required.

Which software is needed?

The syllabus specifies access to spreadsheet software, Python and JupyterLab for the lab examination. Ask the school about the exact approved local environment and file workflow instead of assuming a home web editor is identical.

Are calculators allowed?

An approved calculator may be used in both papers. It does not replace logic, code design, or validation.

Can children rely on AI-generated code?

No. AI-assisted examples can contain errors, out-of-scope libraries or misunderstood requirements. The student must understand and independently test any solution and comply with school assessment rules.

What if a program runs but produces the wrong answer?

That may be a logic error. Compare expected and actual output, trace program state and test boundary values before altering the code.

What is a normal or boundary test?

A normal test checks ordinary valid input; a boundary test checks a value at or near the limit of a permitted range. Error tests cover invalid input. All are useful for revealing weaknesses.

How can parents help if they do not code?

Ask the student to state the program’s purpose, demonstrate two inputs, explain one surprising result and show the correction. This encourages ownership of the solution.

How important is file saving?

The lab paper includes time to save softcopy work for marking. Practise the school’s expected filenames, folders and final verification; correct unsaved work is not the same as correctly submitted work.

How should spreadsheet mistakes be corrected?

Check what the cell is meant to calculate, the reference type, formula and input data. Then copy the formula to a fresh row and verify that it behaves correctly.

Is Computing just preparation for an IT career?

No. Logical thinking, reliable data handling, security and ethical judgment are useful in many subjects and industries. A single K349 grade does not promise a career.

How do I choose tutoring?

Seek specific help for the demonstrated problem, evidence of independent working code and useful feedback. Avoid promised distinction grades, secret examinations or exercises dependent on software the school does not use.

What post-secondary route follows K349?

There is no automatic route. Check the complete SEC grades and 2028 admissions framework, plus current course prerequisites.

What should I ask the teacher?

Confirm K349, the software environment, actual strengths in all five modules, Python/spreadsheet errors, lab submission requirements and next focused practice targets.

10. Parent checklist and conclusion

  • Confirm the 2027 G3 Computing K349 entry and approved software.
  • Know Paper 1’s five-module scope and 60% weighting.
  • Know Paper 2’s programming and spreadsheet tasks and 40% weighting.
  • Build correct binary, logic and networking concepts.
  • Require the child to explain, write and test Python independently.
  • Practise spreadsheets with cell references and reliable data.
  • Check normal, error and boundary cases, not only a single sample.
  • Rehearse saving and submitting all required digital files.
  • Protect student privacy, appropriate AI use and school assessment integrity.
  • Balance revision with rest and check 2028 post-secondary criteria.

Computing mastery is not having a computer do something impressive once. It is being able to describe a problem, represent data appropriately, design a method, test the result, correct mistakes and consider the effect of technology on people. Parents can support those habits through calm explanations and small independent tasks without needing to become programmers themselves.

Official references: SEAB 2027 K349 Computing syllabus, SEAB SEC overview and MOE’s 2026 post-secondary admissions announcement. Follow the school’s exact exam-software and candidate instructions.