Programming Tuition in Singapore
Programming tuition in Singapore teaches learners to write, debug and structure code — from beginner Scratch and Python through MOE O-Level Computing (7155) and H2 Computing (9569) to university CS modules. A tutor builds syntax fluency, computational thinking and project work, paced to the learner's level and goals. The current Computing syllabuses are examined by a written paper and a timed lab-based practical, so tuition trains both theory and debug-under-pressure coding.
Last updated May 2026
Coding tuition, in plain English
Inside the lessons: from first loop to real projects
Programming tuition in Singapore teaches learners to write, debug and structure code, from beginner Scratch and Python through to MOE O-Level Computing (syllabus 7155, the G3 Computing subject under Full Subject-Based Banding) and H2 Computing (syllabus 9569) for A-Level, plus the data structures expected in NUS, NTU and SMU first-year modules. Lessons pair syntax fluency with computational thinking and real project work.
- 01Python, Java, C++ and JavaScript
- 02MOE O-Level Computing 7155 and H2 Computing 9569
- 03Algorithms and computational thinking
- 04Project-based portfolio building
- 05University CS module support
- 06Home or online islandwide
Syllabus coverage
Python, Java, C++ and MOE Computing, covered
Beginner code through exam Computing and university CS
Foundations & computational thinking
First language and logic
Variables and data types; Conditionals and loops; Functions and parameters; Reading errors and debugging; Block-to-text transition (Scratch to Python)
MOE O-Level Computing (7155)
Paper 1 theory and Paper 2 practical
Algorithm design and pseudocode; Data representation and number bases; Spreadsheets and the Python practical; Databases, SQL and networking; Security and ethics
H2 Computing (9569)
JC algorithms and the lab paper
Data structures and algorithm efficiency; SQLite databases; Flask web apps with HTML and CSS; Object-oriented programming in Python; Written-paper and lab-paper technique
Advanced & university CS
Data structures and OOP
Recursion and complexity (Big-O); Java and C++ for university modules; Linked lists, stacks, queues and trees; Version control with Git; CS assignment debugging support
From Scratch blocks to a Computing exam
Where programming tuition fits in the Singapore pathway
Mapped to MOE and university levels
- 1
Primary / Secondary (enrichment)
Scratch and beginner Python — computational thinking, simple projects and STEM confidence, with no exam attached.
- 2
Secondary (O-Level Computing 7155)
The full MOE O-Level Computing syllabus: Paper 1 written theory and a Paper 2 lab practical built on Python, spreadsheets and JupyterLab. This is the G3 Computing subject under Full Subject-Based Banding.
- 3
Junior College (H2 Computing 9569)
A-Level H2 Computing — algorithms, data structures, SQLite databases and Flask web apps, assessed by a 3-hour written Paper 1 and a 3-hour lab-based Paper 2.
- 4
University
Introductory CS modules at NUS, NTU, SMU, SUTD and SIT — data structures, recursion, OOP and assignment support in Java, C++ and Python.
Before you start
What coding learners and families ask first
Logic before syntax
Beginners progress fastest when computational thinking — breaking a problem down, sequencing, conditionals and loops — is built before language details. Teaching the thinking first means a learner can later pick up Python, Java or C++ quickly, because the mental model is already in place.
O-Level and H2 Computing are Python-based and lab-examined
O-Level Computing 7155 uses Python for its Paper 2 lab practical (with spreadsheets and JupyterLab); H2 Computing 9569 uses Python with SQLite and Flask for its Paper 2 lab paper. Both also have a written theory paper covering data, algorithms, databases, networking and security — so programming tuition covers far more than just writing code.
The exam is now timed lab coding, not a coursework project
The current 7155 and 9569 syllabuses removed the standalone project; assessment is one written paper plus one timed lab paper. A student who can code calmly at home but freezes when the clock starts will lose marks, so a large part of senior tuition is rehearsing the timed, debug-under-pressure lab workflow.
We coach the work, we do not do it
Practical exams and university assignments must be the learner's own. Our role is to teach the underlying concepts and the debugging process so the student can complete, test and defend their own submission — never to write it for them.
Stage by stage
Programming tuition by stage in Singapore
Matching the language, focus and format to the level
| Stage | Typical language | Focus | Format |
|---|---|---|---|
| Primary / lower Secondary | Scratch then Python | Logic, motivating projects, confidence | Home or online |
| O-Level Computing (7155) | Python, spreadsheets | Paper 1 theory, Paper 2 lab practical | Home or online |
| H2 Computing (9569) | Python, SQL, Flask | Algorithms, databases, lab + written papers | Home or online |
| University CS | Java, C++, Python | Data structures, OOP, assignments | Online preferred |
Who we coach
Who learns to code with us
We match the tutor to the level and the goal
Young beginners and their parents
Primary and lower-Secondary children new to coding, where the goal is logic, confidence and genuine STEM interest before any exam pressure.
- No prior coding
- Short attention without engaging projects
- Block-to-text transition
O-Level Computing students
Secondary students taking Computing 7155 who need the Python practical, spreadsheet tasks and the written theory paper coached together.
- Python practical debugging
- Pseudocode and tracing
- Databases, networking and security theory
JC H2 Computing students
Pre-university students facing the H2 9569 algorithms, data structures, SQLite and Flask lab paper alongside the written paper.
- Algorithm design and efficiency
- SQLite and Flask under time
- Timed lab-paper technique
University CS students and adult learners
NUS, NTU, SMU, SUTD or SIT undergraduates — and self-directed adult learners — needing introductory modules, data structures and assignment support.
- Data structures and complexity
- Object-oriented design
- Version control and tooling
How code is taught
The way programming tuition actually builds a coder
The method, a real debug, and the tools we put in a learner's hands.
Read-trace-predict-run: how we make debugging a skill, not luck
Most struggling coders change random lines until the error disappears. We teach a repeatable loop that turns debugging from guesswork into a method — the single habit that most separates a confident coder from a stuck one.
- 1
Read the error, not the panic
Start at the bottom line of a Python traceback — the actual error type and message — and the exact line number, instead of skimming the wall of red text.
- 2
Trace the values by hand
Walk through the loop or function one iteration at a time on paper, writing down what each variable holds, so the gap between what you think the code does and what it does becomes visible.
- 3
Predict before running
Say out loud what the next line should output before pressing run. A wrong prediction is the fastest way to find a wrong mental model.
- 4
Run, compare, isolate
Run, compare actual against predicted, then add a single print or use the debugger to narrow the fault to one line — change one thing at a time.
A real bug, debugged the way we teach it
The problem
A student's Python function is meant to return the average of a list of marks, but average([80, 90, 100]) keeps returning 0. The code is: `def average(marks): total = 0 for m in marks: total = m return total // len(marks)`
Worked solution
- 1Read: there is no error message — the code runs but gives the wrong answer. This is a logic bug, so tracing by hand is the tool, not the traceback.
- 2Trace by hand: total starts at 0. Iteration 1: total = 80. Iteration 2: total = 90 (it overwrites, it does not add). Iteration 3: total = 100. After the loop total = 100, not 270.
- 3Spot the fault: the line `total = m` replaces total each time; it should accumulate with `total = total + m` (or `total += m`).
- 4Then notice a second issue: `//` is integer division. 270 // 3 = 90 here by luck, but 270 // 4 would drop the decimal. For a true average use `/`.
- 5Fix: change to `total += m` and `return total / len(marks)`. Now average([80, 90, 100]) returns 90.0.
- 6Confirm with an edge case the student didn't try: an empty list would crash on `len(marks)` being 0 — so a robust version guards `if not marks: return 0` first.
Answer: total += m and return total / len(marks) — and guard the empty list
Two of the most common beginner faults sit in five lines: overwrite-instead-of-accumulate, and integer division silently dropping decimals. Tracing values by hand finds both faster than re-reading the code, which is exactly why we drill tracing before debuggers.
The programming toolkit we set learners up with
Beginners waste hours fighting setup. We standardise the same tools the MOE Computing papers and first-year university use, so practice matches the exam and the lecture.
Python 3 with JupyterLab
The exact environment of the O-Level Computing 7155 Paper 2 practical, so students rehearse in the software they will be examined on.
A real code editor (VS Code or Thonny)
Thonny's step debugger makes variable values visible for beginners; VS Code carries learners into projects and university work.
SQLite and a Flask scaffold
The database engine and web framework named in the H2 Computing 9569 lab paper, used to build small, testable web apps.
Git and GitHub
Version control so project history is safe, mistakes are reversible, and a portfolio is ready for DSA and university applications.
The MOE Computing exams
Inside the O-Level and H2 Computing papers
Exactly how 7155 and 9569 are built, and where marks slip.
How the O-Level Computing 7155 papers are built
The current O-Level Computing 7155 is assessed by two papers — a written theory paper and a timed lab-based practical — with no separate coursework project. Both must be passed on their own merits.
| Component | What it covers | Marks / weight | Time |
|---|---|---|---|
| Paper 1 (Written) | Structured questions on data representation, algorithms, databases, networking, security and ethics. Tests theory and the ability to read and write pseudocode. | 60% (80 marks) | 2 h |
| Paper 2 (Lab-based practical) | A computer-based exam using Python, spreadsheets and JupyterLab: students write, test and debug working solutions to set problems under timed conditions. | 40% (70 marks) | 2 h 30 min |
How the H2 Computing 9569 papers are built
A-Level H2 Computing 9569 is also examined by two papers with no coursework, spanning all four syllabus sections — programming, data and databases, networks, and computational thinking.
| Component | What it covers | Marks / weight | Time |
|---|---|---|---|
| Paper 1 (Written) | Six to eight structured questions across all four syllabus sections — algorithms, data structures, databases, networking and computational thinking — of varying length. | 60% | 3 h |
| Paper 2 (Lab-based practical) | Four structured problems solved in a computer lab using Python, SQLite and the Flask framework with HTML and CSS, testing practical problem-solving. | 40% | 3 h |
Where programming-tuition students lose marks
In Computing exams, most lost marks are predictable habits rather than missing knowledge — and every one of them is fixable.
Writing code that runs but answers the wrong question, because the problem was never read carefully.
Annotate the question first — inputs, outputs, constraints — and write a one-line plan before touching the keyboard.
In the lab paper, debugging silently and burning time changing random lines when something breaks.
Use the read-trace-predict-run loop and the debugger to isolate the fault to one line, then change one thing at a time.
Losing pseudocode and tracing marks in Paper 1 by writing real Python instead of clear, structured pseudocode.
Practise the syllabus pseudocode conventions and hand-trace tables, which are graded on clarity of reasoning, not on running code.
Confusing the assignment operator with the equality test, or integer division with true division.
Drill the small-but-deadly distinctions (= vs ==, // vs /) until they are automatic, since they cause silent wrong answers, not crashes.
Singapore context
Programming in the Singapore education pathway
The MOE Computing strands, mapped to topics
Both Computing syllabuses are built from the same strands at rising depth. Knowing the strand a question belongs to is half of answering it well.
Algorithms & programming
Pseudocode, tracing, control flow, functions, Python implementation, testing and debugging
Data & databases
Number bases and data representation, spreadsheets (O-Level), SQL and SQLite (H2), records and queries
Networks & the internet
Network types, protocols, the client-server model, and Flask web applications at H2 level
Security, ethics & impact
Cyber threats, safeguards, data privacy and the social and ethical impact of computing
How programming fits Singapore's schools and beyond
Computing sits inside a specific Singapore pathway — from Full Subject-Based Banding choices to the NUS-run olympiad — and tuition is planned around it.
G3 Computing under FSBB
Under Full Subject-Based Banding, O-Level Computing 7155 is offered as a G3 subject; students choose it as an elective, and we coach it toward both the written and lab papers.
Smart Nation and the digital economy
Computing aligns with Singapore's Smart Nation direction, and a coding foundation supports later study and work across the digital economy.
National Olympiad in Informatics
The NOI, organised by the NUS School of Computing, runs Secondary and Junior College categories and is the local pathway toward the International Olympiad in Informatics.
University CS at NUS, NTU, SMU, SUTD, SIT
A strong school grounding in Python, data structures and OOP eases the jump into competitive first-year Computer Science modules across the local universities.
Why Eduprime
Why our coding tuition actually sticks
What separates a real coding specialist from generic tuition
Practitioner tutors who code
Tutors who write software and know the MOE Computing 7155 and 9569 syllabuses — not generalists reading a worksheet a chapter ahead of the student.
Diagnostic before we teach
A free first-session diagnostic finds whether the gap is logic, syntax, debugging habit or exam technique, so coaching targets the real weakness.
Debugging taught as a method
We drill a repeatable read-trace-predict-run loop, so a stuck student gains a process instead of randomly changing lines until something works.
Exam tools, not generic ones
We practise in the same Python, JupyterLab, SQLite and Flask setup the lab papers use, so the exam environment is never a surprise.
Progress you can see
Project commits, paper-by-paper progress notes and a skills checklist keep parents and adult learners informed between lessons.
Fair pay keeps good tutors
Tutors are paid fairly and on time, so strong coders stay with your learner through the syllabus instead of churning mid-year.
Lesson formats
Choose how you learn to code
Choose the format that fits the learner's level and your schedule
1-to-1 home tuition
A practitioner tutor comes to you for fully personalised, hands-on coding.
- Fully personalised pace
- Parent visibility at home
- Best for younger beginners
- Live, side-by-side debugging
1-to-1 online
Live one-to-one with screen sharing, ideal for watching code run line by line.
- Flexible timing
- Screen-shared live coding
- No travel time
- Best fit for JC and university CS
Small group (2-4)
A small, level-matched group sharing cost with peer code review.
- Lower cost per learner
- Peer code review
- Level-matched grouping
- Structured project sprints
Fees
Coding lesson packages and their rates
Transparent, market-rate packages — confirmed after a free diagnostic
Trial
Try a specialist before committing
S$200-400
4 sessions · ~S$50-100 / session
- Free level diagnostic
- Logic and syntax baseline
- Curriculum recommendation
- First progress note
Regular
Weekly coaching through the school year
S$50-100 / hr
Monthly sessions · billed monthly
- Weekly 1-to-1 or small group
- Monthly progress notes
- Paced to school topics or modules
- Project portfolio building
Exam Intensive (O / H2)
Pre-exam written and lab-paper push
S$70-130 / hr
Flexible sessions · by tutor seniority
- Timed lab-paper practice
- Pseudocode and tracing drills
- SQLite and Flask for H2
- Past-paper marking to syllabus standard
Free tutor re-match if the fit isn't right after the first lesson.
Figures are typical Singapore market rates for programming and Computing tuition and are indicative only; your exact rate depends on level, tutor experience, language, format and location, and is confirmed after a free diagnostic. H2 Computing and university CS sit in the premium tier. GST applies where relevant.
Accountability
Watch the code skills compound, project by project
We keep parents and adult learners informed between lessons — accountability, not guesswork
Monthly progress notes
What was covered, what improved, and the next focus — in plain language for parents and learners.
Project commit history
A Git history of the learner's own work, so progress on real projects is visible and reversible.
Syllabus and paper tracking
Where the student sits against the 7155 or 9569 syllabus and their timed-paper results over time.
Skills checklist
Which concepts — loops, functions, recursion, SQL, debugging — are secure and which still need practice.
Our tutors
Meet the engineers who teach
Specialists matched to your learner's level and goals
- MOE O-Level Computing 7155 and H2 Computing 9569 syllabus expertise
- NIE-trained or experienced ex-/current MOE Computing teachers (where available)
- Working software practitioners (Python, Java, C++, SQL)
- Trained in lab-paper and pseudocode marking standards
- Cleared Eduprime screening and a live coding assessment
Mr Tan W.
9 years
B.Comp (NUS School of Computing); ex-MOE Computing teacher
O-Level 7155 and H2 9569, Python practical, pseudocode
“Most students can write code; the marks come from reading the problem first and debugging with a method instead of hope.”
Ms Priya R.
7 years
B.Eng Computer Engineering (NTU); software engineer
H2 Computing, data structures, SQLite and Flask
“The lab paper rewards calm. We rehearse timed debugging until the clock stops being the enemy.”
Mr Daniel Lim
8 years
B.Sc Computer Science (SMU); full-stack developer
University CS, Java, C++, OOP and Git
“First-year CS rewards good habits early. We build version control and clean structure from the very first project.”
Ms Aishah K.
6 years
B.Ed with Computing (NIE); primary STEM specialist
Young beginners, Scratch to Python, computational thinking
“For young coders, logic and confidence come first. Get the thinking right and the syntax follows quickly.”
What families say
Coding learners and families share their take
Representative experiences from learners and parents we've worked with
My son froze in the O-Level Computing lab paper at home, changing random lines whenever something broke. The tutor drilled a debugging routine and timed practicals, and by the prelims he was calm and methodical at the keyboard.
Mrs Tan W.
Parent of Sec 4 boy · Tampines · 1-to-1 home
I took H2 Computing and the SQLite and Flask parts of Paper 2 made no sense from school notes alone. Working through small web apps with my tutor made the lab paper click.
Rachel T.
JC2 student · Bishan · 1-to-1 online
My daughter started Scratch in Primary 5 with no interest in coding. The projects hooked her, and she moved to Python on her own. It never felt like extra homework.
Mr R. Kumar
Parent of P5 girl · Bukit Batok · Small group
I'm an adult learner switching careers and needed Python basics fast. The online sessions were practical and patient, and screen sharing meant my tutor caught my mistakes live.
Marcus L.
Adult learner · Queenstown · 1-to-1 online
First-year data structures at university nearly broke me. The tutor explained recursion and linked lists in a way the lectures never did, and I learned to use Git properly.
Daniel W.
NTU undergraduate · Jurong West · 1-to-1 online
Honest about what coding takes — no promises of an instant A, just steady projects and clear feedback each week. My son's pseudocode and tracing marks improved the most.
Mdm Sarah A.
Parent of Sec 3 boy · Pasir Ris · Small group
Student journeys
From copy-paste to building from scratch
Representative paths from stuck to confident
A Sec 4 student could write Python at home but froze and changed random lines in the timed O-Level Computing lab paper.
- Replaced random edits with the read-trace-predict-run debugging loop
- Rehearsed full timed Paper 2 practicals in JupyterLab
- Drilled pseudocode and tracing for Paper 1 marks
Debugged calmly and methodically under time by the prelims, finishing lab questions with time to check.
Sec 4 student · ~2 terms
A JC2 student understood algorithms but couldn't connect SQLite and Flask for the H2 Computing 9569 lab paper.
- Built small, testable Flask apps backed by SQLite from scratch
- Mapped each lab task type to a reusable code pattern
- Practised four-question timed lab papers to the syllabus standard
Approached the lab paper with reusable patterns instead of panic, completing all four structured problems.
JC2 student · ~3 terms
A first-year university student was overwhelmed by data structures and had never used version control.
- Rebuilt recursion and linked lists from first principles
- Adopted Git for every assignment from week one
- Refactored assignments toward clean, testable structure
Submitted assignments that ran and were defensible, with a tidy commit history behind them.
University undergraduate · One semester
Getting started
From first lesson to a program that runs
How starting programming tuition with Eduprime works
- 1
Free needs assessment
We discuss the learner's level, goals (syllabus, enrichment or university) and any prior coding experience.
~15 min - 2
Tutor matching
We shortlist tutors fluent in the right language and level — Scratch and Python through Java and C++.
1-3 days - 3
Diagnostic lesson
The first session establishes the learner's logic and syntax baseline and sets a realistic plan.
Lesson 1 - 4
Skill building
Concepts and syntax are built through guided, hands-on coding, with debugging practised actively rather than watched.
Ongoing - 5
Project or exam application
Learning is applied to a portfolio project, the 7155 or 9569 syllabus and its lab paper, or university assignments.
Toward goals - 6
Review & progression
Progress is reviewed and the next language, data structure or topic is planned.
Each term
Scope at a glance
What programming tuition with Eduprime covers
Honest scope — structured coverage, not guaranteed grades
- Scratch to C++
- Beginner to advanced languages
- 7155 & 9569
- MOE Computing syllabuses
- Uni CS
- Intro module support
- Islandwide
- home or online
Common questions
Languages, pathways and parent questions about coding
Straight answers on languages, the 7155 and 9569 syllabuses and exam papers
Start writing real code
Start Programming Tuition in Singapore
Free diagnostic and a coding tutor matched to your level and goals.
- O-Level 7155 & H2 9569 Computing coaching
- Read-trace-predict-run debugging drilled
- Python, SQLite, Flask, Git portfolio
Eduprime — Singapore's coding specialists, aligned to the MOE Computing 7155 and 9569 syllabuses and to university CS.