Course Overview

Welcome & introduction

Welcome to Higher Computing Science. This page is your starting point — read it properly at the beginning of the year, then come back to it whenever you need a reminder of the bigger picture. It covers exactly what we'll learn, when, how you'll be assessed, and what you need to do to succeed.

Higher Computing Science is one of the most practical and transferable qualifications you can take at school. This isn't just about learning to code (though you'll do a lot of that). Over the course of the year you'll learn how computers work at a hardware level — how data is stored in binary, how the processor fetches and executes instructions. You'll learn how professional software developers design and build systems, using Python as your working language. You'll learn how databases store and retrieve millions of records efficiently, and how to query them with SQL. And you'll learn how websites are built from scratch using HTML, CSS, and JavaScript.

These are real, in-demand skills. Computing Science graduates go into software engineering, data science, web development, cybersecurity, AI research, and dozens of other fields. The specific content of this course — Python, SQL, web development, algorithms — maps directly onto what employers and universities are looking for.

The course is genuinely challenging — there's no point pretending otherwise. You'll need to learn precise technical vocabulary, practise converting numbers between representations until it's fast and reliable, write and debug code, design databases, and create working websites from scratch. Some topics will click straight away; others will need repeated practice before they feel natural. That's completely normal and it's part of what makes the qualification meaningful.

What makes it very achievable is this: the SQA exam is highly predictable. The same types of questions come up year after year. The pupils who succeed at Higher Computing Science are rarely the most "naturally gifted" — they're the ones who turn up, practise consistently, keep their notes organised, and ask questions when they're stuck. If you do those four things, you'll do well.

The four units

The course is divided into four units, taught in sequence across the year. Each unit has its own character — CS is analytical, SDD is practical, DDD is structural, WDD is creative — but they share an underlying logic about how good systems are designed, built, and tested.

Your timetable

You have five Computing Science lessons per week across three days, giving approximately 160 hours of taught time across the year. The new timetable starts 1 June 2026.

What each lesson type is good for

Double lessons (Monday and Thursday, 120 minutes) are where most of the practical work happens. 120 minutes is enough time to introduce a concept, work through examples together, and have a proper go at tasks — without the bell interrupting you mid-problem. These are the lessons for writing Python, building databases, coding websites, and doing multi-step worked examples. Use the full time: if you finish the set tasks early, start the extension or revisit something you're not confident on.

Single lessons (Tuesday, 60 minutes) work well for theory, discussion, and consolidation. We'll review what happened in the previous double, look at exam-style questions, check understanding of tricky concepts, and occasionally do pair activities. Don't make the mistake of thinking "no coding today" means a lighter session — theory questions are where many marks are lost in the final exam.

Year at a glance

Below is an overview of when each unit runs. CS is woven through Term 1 doubles rather than taught as a single block, so you'll see it alongside SDD throughout autumn.

Assessment

Your final grade comes from two components: a question paper (80 marks) sat in the SQA exam diet, and an assignment (40 marks) completed under supervised conditions in school. Together they give a total of 120 marks.

The Prelim

The prelim is an internal school exam that historically runs across the first three weeks of January 2027. It uses the same format as the SQA question paper — both sections, same structure, same timing — and gives you a realistic trial run of the real exam with time to act on the feedback.

Take the prelim seriously. The feedback you get from it — specifically, the questions you dropped marks on — is one of the most valuable things in the entire course. Pupils who carefully review their prelim paper and fix their gaps before May consistently perform better in the real exam. Pupils who file it away and move on do not.

What this course expects of you

The following aren't generic "work hard" advice. They're specific habits that separate pupils who find Higher Computing Science manageable from those who struggle. Read them honestly.

• 1
  Keep up with lesson notes

  Lesson pages go live the morning of each lesson. If you miss a lesson, read the page and catch up before the next one. The notes from September become the revision material in January. A gap in October is much harder to fill in December than it would have been in October.
• 2
  Practise conversions and algorithms until they're automatic

  Binary conversion, two's complement, and the three standard algorithms (linear search, find min/max, count occurrences) come up every single year. They require no notes in the exam — just instant, reliable recall. The only way to get there is repeated practice, not re-reading. Do a conversion every day for a week; it'll stick in a way that passive understanding won't.
• 3
  Write code regularly outside of lessons

  Twenty minutes of Python a couple of times a week compounds enormously over a year. You don't need a project — open VS Code and try something. Redo a worked example from scratch without looking at the solution. Attempt a past-paper algorithm question. The act of typing code (not just reading it) is what builds the muscle memory that gets you through the assignment under timed conditions.
• 4
  Read exam questions carefully

  More marks are lost to misreading questions than to not knowing the content. Pay attention to command words: "describe" wants a description, "explain" requires a reason, "identify" just needs a name. Check the mark allocation — a 3-mark question needs three distinct points. Practise annotating questions before writing your answer; it takes 30 seconds and consistently leads to better responses.
• 5
  Ask questions — don't hope it'll click

  If something doesn't make sense, ask. In class is always best — other people probably have the same question. If the lesson moves on before you get the chance, come to supported study or send a Teams message. There are no silly questions in Computing Science. The alternative — hoping confusion will resolve itself — rarely works, and the topics build on each other.
• 6
  Attempt past paper questions from early in the course

  You don't need to wait until April to use past papers. Once you've covered a topic, find the relevant questions from previous years and attempt them under exam conditions — no notes, timed. This tells you immediately whether you understood what you think you understood. Papers from 2023, 2024, and 2025 are freely available on the SQA website (see Resources).
• 7
  Use worked examples as revision tools, not just reading material

  Every lesson page has worked examples. The most effective way to revise from them is to cover the solution, attempt the problem yourself, then check. When you get something wrong, work out exactly where and why — not just "I got it wrong". Understanding your errors is most of what revision actually is.

How this course is organised

Lesson pages

Every lesson has a dedicated page on this website. Each page follows exactly the same structure, so once you're used to it, you'll always know where to find things:

• Learning intentions — what we're aiming to learn in this lesson
• Success criteria — specific, checkable things you should be able to do by the end
• Notes and explanations — the lesson content, with concepts explained and examples worked through step by step
• Worked examples — full solutions showing method, not just answers
• Tiered tasks — three levels of questions (see below)

When pages are released

Lesson pages go live on the morning of the lesson — not before. Pages are updated right up to the lesson and may change based on what was covered in the previous one. If you miss a lesson, the page will still be there — use it to catch up before the next class.

The three task tiers

Every lesson includes three levels of tasks. They're not labelled by ability — they're labelled by depth:

Past papers and marking instructions

SQA past papers for Higher Computing Science are freely available on the SQA website. The Resources section below has the links you need. Marking instructions (the official mark schemes) are published alongside each paper. Use both. Get into the habit of marking your own work against the official criteria — it is one of the most effective revision techniques available to you, and it's completely free.

Organising your files and notes

You will use three different places to store your work this year. Each has a specific job. Getting this right from the start saves a lot of confusion — especially when the assignment comes around and you need to find everything quickly.

Set up your H drive — working files

The H drive is for files you are actively editing during class: Python code, database files, and web project files. Set up this structure once, at the start of the year.

Set up your OneDrive — documents and PDFs

OneDrive is linked to your school Microsoft 365 account. Create a mirrored structure here — but include all four units, since every lesson generates a PDF.

Set up your OneNote Class Notebook

Your teacher has already created the Class Notebook — you don't need to make it. You just need to find it and open it in the desktop app.

Your workflow — every lesson

Follow these five steps at the end of every lesson. It takes about two minutes and builds your entire revision resource automatically.

Detailed export steps

Naming convention — quick reference

Python setup

We use Python 3 throughout the Software Design & Development unit. Python should be available on school computers, but setting up your own machine lets you practise at home. Here's a step-by-step guide that assumes you've never installed Python before.

print("Hello, Higher Computing!")

python hello.py          # Windows
python3 hello.py         # Mac or Linux

Using Python on an iPad

VS Code and the standard Python install don't run on iPadOS. Two alternatives that work well:

• Replit (replit.com) — free, entirely browser-based, no install needed. Create a free account, start a new Python Repl, and you have a working Python editor and runner in your browser. Works well on iPad and any device.
• Pythonista — a paid app (approximately £10) on the App Store. A full Python 3 environment with a good code editor, built for iOS. Worth it if you plan to code regularly on iPad.

SQL setup

For the Database Design & Development unit, you'll be writing SQL queries against a relational database. The easiest setup — and the one we'll use in lessons — needs no installation at all.

Recommended: SQLite Online (browser-based, no install)

Go to sqliteonline.com in any browser. You can create tables, import data, and run SQL queries entirely in the browser — no account required, no download, no configuration. It works on iPad, any laptop, and any school computer. This is what we'll use in class.

Alternative: DB Browser for SQLite (free desktop app)

If you prefer a desktop application, DB Browser for SQLite is a free, open-source tool available from sqlitebrowser.org. It gives you a visual interface for building and viewing tables alongside a SQL editor. Works on Windows, macOS, and Linux. Not available on iPad.

Useful resources

SQA and official materials

Python

Web development (for the WDD unit, starting November)

Supported study & getting help

Supported study sessions

Supported study sessions run throughout the year. They're a chance to ask questions, work through past papers, get help with code in a relaxed environment, or just use the time to catch up. Sessions are most productive if you come with a specific question or a past paper attempt to review.

Working with other people

One of the most underrated revision strategies in Computing Science is working with a classmate. Explaining a concept forces you to understand it properly — much more than re-reading does. Pair programming (one person writes, one talks through the logic) is a genuine technique used by professional software teams and works well for exam prep too.

Quiz each other on binary conversions. Talk through algorithm trace tables together. Review each other's SQL queries. This kind of collaborative practice is encouraged — just make sure your assignment submission is your own independent work.

A note for parents and carers