Assessments & Scale

How to Run an Online Exam for 1,000 Students at Once

Exam day is not steady traffic. It is four bursts stacked on top of each other — everyone signs in, everyone presses Start, everyone autosaves, everyone submits in the last two minutes. Here is what actually breaks at a thousand candidates, and the measured numbers from a full-scale test on live infrastructure.

1,000 concurrent candidates
Every step under half a second
Verified paper by paper

Executive Summary

If you are planning a scholarship test, a mock series or a term-end exam for a large cohort, the question that matters is not how many learners the platform can hold. It is what happens in the four narrow windows where all of them do the same thing at the same moment. A full exam journey measured on production with 1,000 simultaneous candidates kept every step under half a second, filed every paper correctly, and left roughly two thirds of the server capacity unused. The rest of this piece explains which parts of exam day are actually hard, and how to check your own numbers before candidates sit down.

A thousand candidates sitting the same online exam at the same time
A thousand candidates, one paper, one moment — the load pattern that decides whether exam day holds.

1. Exam Day Is Four Bursts, Not a Steady Stream

Most capacity conversations start with the wrong number. A thousand candidates spread across a two-hour exam is a modest, comfortable load — roughly seventeen save operations a second. What decides whether exam day holds is not that average at all. It is the four moments where a thousand people do the same thing within the same sixty seconds.

T−15 to T0

The sign-in burst

Candidates arrive in the quarter hour before the paper opens, often on devices they have not used for an exam before. This is short, sharp, and entirely front-loaded.

T0 to T+5

The start burst

Everyone presses Start within the same few minutes. Each candidate is served the full question paper, and an attempt is created for them. This is the heaviest read the system performs.

Through the paper

Continuous autosave

Answers and time state stream to the server throughout the attempt rather than only at the end. Predictable, steady, and the reason a dropped connection costs a candidate nothing.

Last 5 minutes

The submission rush

Objective papers are scored as they are submitted, and late finishers cluster into the final two minutes. This is where an exam platform either holds or visibly stalls.

Capacity is set by the worst of those four windows, never by the average. An exam platform that looks perfectly healthy on a dashboard at 11:00 can still stall at 11:02 when the start burst lands, and again at the closing bell.

2. What We Measured at 1,000 Candidates

On 28 August 2026 we ran a complete exam journey against live production infrastructure — the same servers that serve institutes every day, not a scaled-up rig assembled for the occasion. One thousand simulated candidates signed in across a ten-minute window, started within three minutes of each other, worked through a thirty-question objective paper with autosaves every sixty seconds, and submitted.

The figures below are 95th-percentile times: the experience of the unluckiest candidate in every twenty, not a flattering average.

Step in the examResponse timeWhat it covers
Signing in146 msCandidate authentication as the exam window opens
Loading the paper465 msDelivering the full question paper to each candidate
Starting the exam134 msEveryone pressing Start inside the same few minutes
Autosaving answers140 msContinuous background saving during the attempt
Submitting139 msFinal submission and scoring, including the end rush

Zero failed requests across roughly 11,000 calls. All 1,000 papers were then checked individually in the database — every one submitted, scored and recorded. Exam servers peaked at under a third of their allocated capacity.

3. The Two Things That Actually Break

Here is the part worth taking away, whichever platform you run. At no point in our testing was the constraint the database, the network or the login service. Those sat idle. Both failure modes we found were software design problems, and both were invisible until a thousand people did the same thing simultaneously.

Failure mode one: work that quietly runs one at a time

Anything a submission triggers — analytics, rank calculation, a notification — must run away from the request that the candidate is waiting on. If it does not, a thousand submissions consume every available request handler, and the queue backs up onto candidates who were doing nothing more demanding than autosaving an answer. The symptom is misleading: processor usage stays low while response times climb, because the threads are waiting rather than working.

Failure mode two: a green dashboard that is not telling the truth

A load test can report a perfect run while records are quietly wrong. In one round every submission returned success, yet a small share of attempts had not been stored as submitted — a background recalculation had overwritten them a moment later. No load-testing tool would have caught it. It only showed up because every attempt was checked against the database afterwards. That reconciliation step is now part of how we test, and it is the question worth asking any vendor who quotes you a concurrency number.

4. Resilience Is a Candidate Feature, Not an Infrastructure One

The exam experience is built for unreliable connections rather than assuming good ones. Answers and time state stream to the server continuously during the attempt, with a live network indicator on screen. If a browser crashes or a phone dies mid-paper, the candidate signs back in and rejoins the running attempt exactly where they were. Timers run at assessment, section and question level with automatic submission when they expire, so a lost device does not become a lost paper.

Live exam monitoring console showing attempted, ongoing and pending candidates
The monitoring console during a live exam: who has finished, who is still working, and who has not started.

5. Exam Day Needs a Control Room

Capacity is only half the problem. The other half is what an invigilator can do at 11:20 when a candidate reports a frozen laptop. While the exam runs, staff see participants split into Attempted, Ongoing and Pending tabs with live counters, search and filters, and can act individually or in bulk.

Add extra time

Grant additional minutes to ongoing attempts, one candidate or many at once.

Close submissions

Force-submit attempts still running past the deadline, individually or in bulk.

Grant re-attempts

Give selected candidates another attempt after a genuine disruption.

Release results

Publish per candidate, in bulk, or for the whole assessment when set to manual release.

Candidates can also raise extra-time and re-attempt requests from inside the exam where the institute allows it, and staff approve them from the same console. Announcements broadcast to everyone mid-exam without interrupting anyone's attempt.

6. Written Papers Scale Better Than Screens

Exams where candidates upload a scanned answer sheet behave differently, and counter-intuitively they are lighter on the platform than on-screen papers. The candidate's device receives a secure, single-use link and uploads straight to cloud storage. The file itself never passes through the exam servers, which only handle the paperwork around it.

Diagram showing an answer sheet uploading directly to cloud storage rather than through the exam server
Answer sheets go straight to storage. The exam servers issue the link and record the result, and never carry the file.

We measured that too: 1,000 candidates each uploading a six-page answer sheet of roughly one megabyte, 974 MB of candidate work in total. Every step our servers perform finished in under a fifth of a second, all 1,000 submissions were filed with their sheet attached and queued for marking, and the exam servers peaked at a tenth of their capacity. Because the bytes bypass the platform, a ten-megabyte scan costs it no more than a one-megabyte one — a larger file simply takes the candidate's own connection longer.

7. Build the Paper Faster Than You Schedule It

Scale is wasted if authoring the paper is the bottleneck. Papers can be assembled question by question, pulled from a searchable question bank, imported from a Word document with options and answer keys intact, or generated from existing material you already own.

Turning existing material into structured questions inside the platform.

The paper is usually the slow part

Most institutes already hold years of question papers as PDFs and documents. Turning that archive into structured, auto-gradable questions is what makes a weekly mock series realistic rather than aspirational — and it is a different job from serving the exam on the day.

8. What to Ask Before Your Next Large Exam

Whether you run your exams on Vacademy or elsewhere, these are the questions that separate a tested platform from a hopeful one:

  • Has the number been measured, or estimated? Ask for the date, the cohort size and the response times per step — not a marketing figure.
  • Was it measured on production? A dedicated test environment proves very little about the servers your candidates will actually hit.
  • Were the results reconciled afterwards? Every attempt checked against the database, not just a green report from a load tool.
  • What happens to a candidate who disconnects at minute forty? If the answer is anything other than “they rejoin the same attempt”, plan for disputes.
  • Can staff intervene mid-exam? Extra time, force-submit and re-attempts are exam-day essentials, not luxuries.
Rehearse the exam you are actually going to run

Cohort size is only one variable. Paper length, image-heavy questions and answer-sheet size all change the arithmetic. For any unusually large exam we will simulate your specific setup and give you the measured numbers before your candidates sit down.

Frequently Asked Questions

How many students can take an online exam at the same time on Vacademy?+

A full exam journey was measured on production infrastructure with 1,000 concurrent test-takers on 28 August 2026 — sign-in, paper delivery, start, autosave and submission. Every step stayed under half a second at the 95th percentile, all 1,000 papers were submitted and scored, and the exam servers peaked at under a third of their allocated capacity. Cohorts of 300 run on the everyday configuration with no preparation at all.

What actually breaks when a thousand students start an exam together?+

Almost never the network or the database. Exam day is four separate bursts — a sign-in burst, a start burst, steady autosaving through the paper, and a submission rush at the end — and capacity is set by the worst of them, not the average. The two failure modes that matter are work that runs one-at-a-time on the request thread, and background jobs that pile up faster than they drain. Both are software design issues, which is why they only appear under a real concurrent load test.

What happens if a student's internet drops during the exam?+

Answers and time state stream to the server continuously through the attempt, not only at submission, and the exam screen shows a live network status indicator. If the app or browser closes mid-exam, the learner rejoins the running attempt and continues exactly where they were. Work completed before a disconnection is already on the server.

Can staff intervene while an exam is running?+

Yes. The live monitoring console splits participants into Attempted, Ongoing and Pending tabs with live counters, and supports both individual and bulk actions: add extra minutes to ongoing attempts, force-close submissions, grant re-attempts, remove pending participants, send reminders to those who have not started, and release results.

Does a bigger question paper reduce how many students can sit the exam?+

It affects the marking work, not the delivery. Scoring effort grows with the number of questions, so for a very long paper — 100 questions or more — or one heavy with images, plan on a smaller simultaneous cohort and rehearse the exact paper first. For a standard objective paper of 30 to 50 questions, 1,000 concurrent candidates is the measured figure.

Can we test our own exam at our own cohort size before running it live?+

Yes, and it is worth doing for any unusually large exam. The same test rig used to produce these numbers can simulate a specific cohort size, paper length and answer-sheet size, and return measured response times before candidates sit down. A rehearsal takes roughly half an hour.

Ready to experience the
Future of Learning?

Join thousands of educators and institutions who have switched to Vacademy for a seamless, automated, and intelligent teaching experience.