Did you know? A programme can run without a syntax error and still produce the wrong answer. Imagine software for a school library that accepts an invalid book count but prints a plausible total. The computer successfully executes the instructions, yet the input validation or algorithm is logically incorrect. That distinction—valid execution versus correct behaviour—is central to G3 Computing K349 in the 2027 Singapore-Cambridge Secondary Education Certificate.

The published K349 examination does not consist solely of writing Python code. It assesses computing fundamentals, algorithms and programming, spreadsheets, networking, and the wider impact of computing. The practical examination requires working computer files, testing, refinement and reliable submission.

This guide explains the verified 2027 K349 two-paper scheme and uses original exercises in Python, binary, Boolean logic, spreadsheet references and data validation. It is written for Punggol parents and students who want to understand what good Computing tuition should actually teach, rather than mistake a working demo or a copied tutorial for mastery.

The exact SEC 2027 Computing subject code

The SEAB 2027 G3 school-candidate syllabus register lists Computing K349, previously code 7155. The official 2027 G3 Computing K349 syllabus defines its precise assessment objectives, permitted programming and spreadsheet topics.

This is different from G2 Computing K237, whose course includes visual programming and media software in a different lab structure. A tutor should never advertise one generic “2027 Computing paper” without identifying the registered subject level.

The school confirms whether G3 Computing is offered, which applications are used in class and how practical preparation is organised. A child’s interest in coding games does not automatically establish their official K349 registration.

The two K349 papers and their exact weighting

All K349 candidates take two compulsory papers, with all questions compulsory:

• Paper 1 — Written Examination: 2 hours, 80 marks, 60% of the final subject result.
• Paper 1 can use multiple-choice, short-answer, matching, cloze and structured questions. It assesses all five modules.
• Paper 2 — Lab-Based Examination: 2 hours 30 minutes, 70 marks, 40%.
• Paper 2 has one spreadsheet question and four to five programming questions, assessing Algorithms and Programming and Spreadsheets.
• Candidates have access to a computer with spreadsheet, Python and JupyterLab software as provided by the examination centre; a Python quick-reference guide is supplied.
• Required practical work is submitted as softcopy files, and the 2-hour-30-minute duration includes the time needed to save those files.
• An approved calculator may be used in either paper under the published syllabus.

The raw marks total 150, but the 60%/40% weighting determines the final component contribution. A student cannot calculate a correct weighted overall result by simply adding marks from two papers with different denominators and weightings.

The five official modules

K349 is organised into:

• Module 1 — Computing Fundamentals: architecture, memory and storage, data representation, binary and hexadecimal, two’s complement, and Boolean logic gates.
• Module 2 — Algorithms and Programming: problem analysis, flowcharts, Python, selection and iteration, functions, testing, validation and incremental development.
• Module 3 — Spreadsheets: cell references, formulas, conditional logic, lookups, statistics, formatting, dates and goal seeking.
• Module 4 — Networking: network concepts, local and wider communication, addressing, routing and related technical principles.
• Module 5 — Impact of Computing: technology, ethics, data, security, privacy, intellectual property and wider consequences.

The first written paper draws on all five modules. The lab focuses on the programming and spreadsheet modules, not a random selection from all five. This is why a generic Python-only class is incomplete K349 preparation.

Why first-principles problem analysis comes before typing code

A programmer needs to understand inputs, valid inputs, outputs and correct outputs. These are different ideas.

A user can type a number that follows the allowed format but is factually wrong. A programme may compute a mathematical result accurately from the invalid value and still fail to solve the real problem.

Suppose a fictional school activity limits participants to ages 12–16. The software should check the relevant range and format before processing a numeric age.

A tutor should ask what happens if someone enters 12, 16, 11, 17, a blank string or the word “fourteen”. These cases reveal whether the solution is robust, not merely successful with the author’s preferred demonstration input.

Worked example 1: binary representation of a number

The decimal number 13 can be expressed as 1101 in binary, because 1×8 + 1×4 + 0×2 + 1×1 = 13.

A student who writes 1110 has represented 14 instead, since 8 + 4 + 2 = 14. Reading positional values matters more than counting the number of ones.

For an 8-bit unsigned representation, 13 is 00001101. Leading zeros do not change the value, but they help show the specified fixed number of bits.

Ask students to convert another number, such as 10. It becomes 1010 in binary. Then reverse the task: calculate the decimal value of 1010 from its bit positions.

These small examples establish what it means for information to be represented in a number system other than base ten.

Worked example 2: negative numbers and two’s complement

Under the common 8-bit two’s-complement representation, positive 5 is 00000101.

To represent −5, invert all eight bits to obtain 11111010, then add one to obtain 11111011.

A student who simply puts a minus sign before the binary digits has not used the representation the question asks for.

The number of bits matters. A fixed-width representation has a finite range, so the programmer must not treat an arbitrary large integer as representable in the same eight bits without considering overflow.

A tutor should teach the relationship among sign, bit width and representation, then ask a changed question using −3 or another small number.

Worked example 3: Boolean logic answers a precise question

Suppose a fictional event-entry rule allows a person to participate if a permission form is present AND the registration is valid.

Let P represent the permission form and R the valid registration. The rule is P AND R.

Both must be true to grant entry. If the form is missing, the result is false even when registration is valid.

Now suppose the rule allows entry when a participant has a valid registration OR an authorised manual override. The OR operator gives a different outcome when only one condition is true.

The distinction is not decorative. Using OR where AND is required could admit people who do not meet the intended conditions.

The K349 syllabus includes AND, OR, NOT, NAND, NOR and XOR gates and De Morgan’s theorem. Students should build small truth tables and explain the logic rather than memorise gate symbols without knowing what they do.

Worked example 4: trace a Python loop

Consider this original short algorithm expressed in Python:

total = 0. Then execute for value in [2, 4, 6]: total += value. Finally print total.

After the first iteration, total is 2. After the second, 6. After the third, 12. The output is 12.

A student who outputs 6 may have read only the final item instead of tracking the running total. Another who outputs 3 may have counted iterations rather than summed the values.

A trace table with columns for iteration, value and total after update makes the logic visible.

The key point is to explain every state change. A pupil should be able to trace a new list without running the program or guessing its answer.

Worked example 5: loop boundaries and the off-by-one problem

In Python, range(1, 5) produces 1, 2, 3, 4. The stop value 5 is not included in this ordinary form of range.

A novice may assume it produces 1 through 5 because the number 5 appears in the code. The result is an off-by-one error.

If a student wants to repeat an action five times, a loop over range(5) has five iterations, with values 0, 1, 2, 3 and 4.

Ask what should be counted: the values printed, the number of iterations or the resulting sum. Those are distinct outputs.

A robust tutor then changes the requested number of repetitions and asks the pupil to justify the start and stop values before running the code.

Worked example 6: functions, parameters and local variables

A simple function can define an operation once and reuse it with different inputs. Imagine a Python function *def double(n): return 2 n**.

Calling double(7) returns 14; calling double(3) returns 6. The parameter n receives the caller’s value and is local to the function in this straightforward example.

A student who believes that every parameter is a permanent global value may confuse how separate calls behave.

K349 expects understanding of functions that accept parameters and/or return values, as well as the distinction between local and global variables.

The useful teaching question is: What information does the function need, and what does it return? This makes decomposition a practical technology for creating programs that are easier to test.

Worked example 7: validation is not proof that a value is true

Suppose a programme permits ages from 12 to 16 inclusive. A range check can reject 11 and 17.

However, a person entering 14 when their actual age is 15 could pass the range check. The input follows the rule but remains factually wrong.

The syllabus distinguishes length, range, presence, format, existence and check-digit validation. Each test addresses a different class of invalid input.

A strong student identifies which test is appropriate for a scenario. A name field should not automatically be validated using the same numeric range rule as an age field.

Test cases must include normal, boundary and invalid inputs. For the age rule, examples include 14, 12, 16, 11 and a nonnumeric string. A robust program must handle conversion failures safely.

Worked example 8: syntax, runtime and logic errors are different

A syntax error occurs when code does not follow the language’s required grammar, such as a missing colon after an if statement.

A runtime error can occur when syntactically valid code tries to perform an invalid operation during execution, such as dividing by zero without handling the case.

A logic error occurs when the program runs but produces an unintended result, such as averaging three scores using a divisor of two.

A good debugging routine starts with observed behaviour and uses a small, controlled test to find the earliest wrong state.

K349 explicitly includes tracing, print-based inspection, incremental testing, backtracking from incorrect output and checking boundary inputs. These methods are valuable because they are repeatable, not just clever one-time fixes.

Worked example 9: spreadsheet absolute and relative references

Original fictional workbook: Column B contains item price and Column C contains quantity. Cell E1 contains a common discount rate of 10%.

A suitable spreadsheet formula in row 2 for the discounted total is *=B2C2(1-$E$1)*.

The row references B2 and C2 should change to B3 and C3 when the formula is copied down. The absolute reference $E$1 should remain fixed, so every row uses the same discount rate.

A pupil who writes E1 without the dollar signs may find that row 2 works but row 3 reads a blank or unrelated E2 cell.

A tutor should ask the student to predict the copied formula before using the spreadsheet, then change E1 and check whether the resulting totals respond as intended.

This teaches both a technical feature and a way of testing whether the formula actually works.

Worked example 10: a formula is different from a typed result

Suppose a fictional school event has expense amounts of $20, $35 and $45.

Their total is $100. Typing 100 in a total cell shows the right answer once, but it will not update if another expense is added or corrected.

A formula such as SUM over the relevant three cells calculates the total dynamically. If an additional $15 is added, the formula’s referenced range must include it to give $115.

A user who produces a screenshot showing $100 has not necessarily demonstrated a working spreadsheet. For a lab exam that requires an editable working file, the formula and range matter.

This is also why a candidate should reopen or test the saved spreadsheet and verify that dependent formulas recalculate correctly.

Worked example 11: lookups and approximate matching

A fictional grade-classification table might group values into ranges, using a sorted threshold column. An approximate lookup can assign a category, but only if the table is organised according to the function’s required conventions.

An exact-match lookup does something different: it seeks a particular key, such as a unique fictional item code.

A student who uses an approximate match on an unsorted threshold table may receive an incorrect category while the spreadsheet still displays a plausible result.

The K349 syllabus includes VLOOKUP, HLOOKUP, INDEX and MATCH and other specific spreadsheet operations. The key is understanding the relationship between a lookup key, table layout, match type and returned value.

The tutor should use invented data and test both an exact code and a boundary value in a threshold table.

Why the networking module still matters

Paper 1 assesses all five modules, including Networking. A student who is skilled at Python but ignores networking may leave part of the written syllabus unprepared.

A MAC address serves local network delivery in the relevant networking model, while an IP address supports routing communication across interconnected networks. They are not two labels for the same task.

A router, network interface and communication protocol have different roles. A pupil should explain what information is required to move data between devices and which part of the system uses it.

There is no need to ask students to publish their real home-network passwords, device identifiers or account information in order to demonstrate understanding. A diagram with fictional devices is sufficient for a sound classroom explanation.

Impact of Computing: accuracy, privacy and ethical choices

Technology can help process data, communicate and support decisions, but the K349 syllabus also concerns the impact of computing on individuals and society.

A data-processing system can run efficiently yet handle personal information carelessly. A machine-learning output can sound confident while being wrong. A website can offer convenience while excluding some users who lack the necessary access.

Students should be able to discuss data protection, security, intellectual property and ethical implications using the scenario provided.

An academic exercise should not require unauthorised access to real networks or accounts. Use fictional datasets, authorised computing environments and school-approved procedures.

The most useful principle is that technical success is not the same as responsible use.

Paper 2: save and verify the real deliverable

The lab exam lasts 2 hours 30 minutes, and that time includes creating, testing and saving the required softcopy files.

A practical checklist:

• Read the task and identify required input, output and file formats.
• Build the spreadsheet or Python solution using the approved software.
• Test it with ordinary values and boundary or invalid cases.
• Inspect formulas, references and code state where errors occur.
• Confirm that the output addresses the original task rather than a different one.
• Save the final files to the location specified by the examination centre.
• Verify the saved deliverables where the approved process allows.
• Leave time for final review instead of continuing to make untested changes until the last second.

Paper 2 requires one spreadsheet task and four to five programming tasks. Practice should therefore include both production tools, not a generic portfolio created in software the school does not provide.

The use of unauthorised AI assistance, plug-ins, personal cloud access or personal USB storage cannot be assumed to be permitted. Follow SEAB and school examination instructions.

An error log that improves Computing rather than just test scores

• Problem misunderstanding: input or output requirements were never correctly identified.
• Representation: binary, two’s complement or Boolean operations used incorrectly.
• Algorithm: loop termination or boundary handling is wrong.
• Variable state: a function modifies or reads the wrong value.
• Validation: illegal inputs are accepted or valid boundary values are rejected.
• Testing: only one happy-path case was tried.
• Spreadsheet reference: an absolute reference becomes relative after copying.
• Lookup: approximate and exact matching are confused.
• File discipline: the required editable deliverable was not saved correctly.
• Ethics: a technically workable plan violates privacy or another important condition.

The tutor should identify the first wrong assumption, show a repair and then ask the pupil to solve a changed problem independently.

A four-stage K349 SEC 2027 revision plan

Term 1: establish fundamentals and problem analysis

Confirm K349. Review binary, Boolean logic, inputs and outputs, Python flow and basic spreadsheet references. Use trace tables and short, testable examples before large projects.

Term 2: build small working programs

Practise functions, loops, dictionaries, files and validation within the official Python quick-reference scope. Implement spreadsheet formulas, lookups and appropriate data processing. Test changed inputs.

Term 3: integrate the written and lab papers

Practise two-hour Paper 1 questions across all five modules. Simulate 2-hour-30-minute Paper 2 using the school’s appropriate Python/JupyterLab and spreadsheet environment, including saving and checking final files.

Final SEC period: focus on reproducibility

Follow official school and SEAB SEC instructions. Revise recurring logic errors, protect adequate rest and avoid risky last-minute software installations or unverified tool assumptions.

How a three-student Computing tutorial should work

A group of three can review the same broken program: one student identifies the expected output, another traces the values and the third proposes a boundary test. After discussion, each pupil should debug a different program independently.

For spreadsheets, one pupil might explain the discount formula, another check copied references and a third test whether changing an input updates the result. The tutor observes the reasoning rather than allowing one child to operate the computer for the entire group.

eduKate’s maximum-three-student, 1.5-hour approach can deliver detailed technical feedback if a qualified K349 Computing specialist and authorised software are available. Confirm the actual timetable and syllabus coverage before arranging a consultation.

Related Punggol reading: preparing for the G3 Python and spreadsheet lab, normal, boundary and invalid tests, the different G2 K237 Computing route and why eduKate teaches groups of three.

Questions parents should ask

• Is the pupil registered for G3 Computing K349, not G2 K237?
• Does the tutor prepare both the 60%-weighted written paper and 40%-weighted lab?
• Can the student trace a loop and explain logic without running it?
• Are spreadsheet absolute, relative and lookup references understood?
• Does the pupil test normal, boundary and invalid cases?
• Can the learner save and verify a working Python or spreadsheet deliverable?
• Are networking, computing fundamentals and ethical impacts included in written revision?

Frequently asked questions

Is K349 a Python-only examination?

No. Paper 1 covers five modules. Paper 2 includes Python programming and spreadsheets, with specified permitted applications.

How long is the K349 lab exam?

Two hours 30 minutes, worth 70 marks and 40%. This includes time to save required files.

Does Paper 1 contain practical coding?

It is a written paper of 80 marks, covering all five modules and using multiple question formats. The lab component is Paper 2.

Can approved calculators be used?

Yes. The published syllabus permits an approved calculator in Paper 1 and Paper 2.

Does a Python program that runs successfully guarantee correct output?

No. Syntax, runtime and logic errors are distinct. A program may execute yet violate the required rule or fail at a boundary input.

The Punggol 2027 takeaway

K349 Computing turns logic and data into reliable working systems. A successful student must understand fundamental representations, design and test Python programs, build correct spreadsheets, interpret networking and ethical consequences, and deliver the right files under the actual two-paper SEC scheme.

Official references: SEAB 2027 G3 Computing K349 syllabus · 2027 G3 school-candidate register. Reviewed 29 October 2026; follow later SEAB and school-specific lab instructions.