From the first lesson to the final grade

Uppcoder runs the whole course: lessons and assignments, a ready coding lab in the cloud, opened from any browser, for every student, multiple-choice and written questions, marking by tests and by people, and every hand-in kept. On its own, or inside the LMS your school already runs.

Coding courses, built to be marked

Every assignment carries its own brief, starter code, tests and a solution, and is tested before students get it: the solution must pass and the starter must fail. The class works in one lab, and every hand-in is marked by running its tests.

Assignments with a brief, starter code, tests and solution, tested before students get them
One lab for the class, with appropriate tools already configured
Each student works in their own totally isolated work tree
Students run their own app on a private link
Submit freezes the work, the tests mark it, and a rubric covers the rest
Published with a version label; kept in git, in our storage or the school's own GitHub or git server

Courses, cohorts and sections

A course holds its own curriculum, its own students and its own environments. Enrol a cohort in bulk, split it into sections for seminar groups or lab slots, and set when access opens and closes.

Create courses with a custom curriculum
Bulk-invite students by email or CSV
Organise a cohort into sections
Enrolment periods and access rules
Teaching assistants with their own permissions
Reuse a course next term without rebuilding it

Labs that are ready before the class is

A lab is built from a starter-code template, so what the student opens already contains the skeleton, the data and the tooling the exercise needs. Their environment is provisioned for them; the first thing they do is write code.

Labs built from starter-code templates
Student environments provisioned automatically
The same stack for every student, every time
Due dates and late-submission policies
Data-science labs open straight into JupyterLab
Nothing for a student to install, on any machine

Collect and mark the work where it was written

Submissions arrive as the environment they were written in, so you review the actual project rather than a zip file that no longer runs. Comment on the lines you mean, and let the grades find their way back to the gradebook you already keep.

Collect submissions per lab and per section
Inline code review and written feedback
Rubrics, so marking is consistent across markers
Teaching assistants can mark within their own sections
Grades synced back to your LMS gradebook
A record of what was submitted, and when

It lives inside the LMS you already run

Uppcoder connects over LTI 1.3, so a Code Lab is a link in the course a student is already looking at. They click it and arrive in their workspace — signed in, enrolled and in the right lab — without a second account to create or remember.

Moodle, Canvas or Blackboard over LTI 1.3
Students launch a Code Lab from inside the LMS
Accounts and enrolment provisioned on first launch
No second password for a student to lose
Grades returned to the LMS gradebook
A setup guide written for whoever administers your LMS

A budget a department can actually approve

Courses, students per course and quotas are set per plan, and usage is measured against them continuously. A cohort cannot quietly cost more than the department agreed to, because the quota refuses rather than overspends.

Course and student caps on every plan
Usage measured per course and per student
Environments that idle cost less than ones being used
Departmental and institutional plans, billed once
Hackathons on their own: a Day Pass, a hackathon plan, or a price from us
A free trial tier for a pilot, before anyone signs anything

A lab is a starting point, not a cage

The template decides what a student opens with, not what they are allowed to do. They have a terminal on their own container and the toolchain in their own home directory, so a student who wants to pull in a library the brief never mentioned can — which is the difference between teaching programming and teaching your setup. What they cannot do is change the machine underneath, so nobody breaks their environment the night before a deadline.

A terminal on their own container, from the first lab
They can install from PyPI or npm what the lab template did not ship
Clone a repository, try a framework, and take it further than the brief
A fresh environment from the same template whenever one is needed
No root, so a student cannot break the machine or anybody else's
The same freedom as a real development machine, without the support load

Not only code: courses with questions

The same platform runs courses with no code at all. Lessons with multiple-choice and written questions, answered in the portal: nothing to install and no lab. The example on the demo is Incident Command basics, an introduction for anyone who may work in an emergency.

Lessons with multiple-choice and written questions, in the portal
Multiple choice marked the moment a student submits
Written answers marked by the educator or a TA against the marking guide
One grade from both parts
Scenarios told in updates, one part at a time
Students can answer again: every hand-in is an attempt

From an empty course to a marked cohort

Build the course — Curriculum, sections and the labs each one needs, from starter-code templates.
Connect the LMS — One LTI 1.3 connection to Moodle, Canvas or Blackboard, and the labs appear in the course.
They click, they code — Each student lands in their own identical workspace. You collect, mark, and the grades go back.

Questions educators ask

What do students need on their own machines?

A browser. The editor, the terminal and the running code are all in our cloud, which is the point — a borrowed laptop and a library Chromebook behave identically.

Do we have to move off Moodle or Canvas?

No. Uppcoder connects to the LMS you already run over LTI 1.3 and sits inside it. Students never see a second login.

What happens between cohorts?

The course and its labs are reusable. A new cohort gets fresh environments from the same templates, so nothing has to be reset by hand.

Can we try it on one module first?

Yes. There is a free trial tier with its own seats and workspaces, which is enough to run a real module before anybody commits a budget.

The environment a student learns in is an ordinary Uppcoder environment. What they build in week one is still theirs to open, run and show somebody in year three.

Talk to us about your department

Pilots for a single module, institutional and departmental pricing, LTI setup with whoever administers your LMS, or hosting inside a particular country — all of it is a conversation rather than a form to fill in. Tell us what your term looks like.