How to choose invigilation display software that actually works across multiple rooms, handles extra time accommodations, and syncs instantly
Running examinations at an international school means juggling IB Diploma papers alongside Cambridge IGCSEs, managing students with 25% and 50% extra time accommodations in the same session, and displaying accurate timing across four different rooms simultaneously.
The wrong exam display software turns this complexity into chaos. The right software makes it invisible.
This guide covers everything exam coordinators need to know about choosing and implementing exam timing software—from essential features to avoid, to the technical architecture that separates reliable systems from frustrating ones.
What Exam Display Software Actually Does
Exam display software replaces the traditional whiteboard or paper signs showing exam timing information. At its most basic, it displays the current time, start time, and end time for an examination on a screen visible to all candidates.
Modern systems go significantly further. They calculate end times automatically based on exam duration, handle multiple simultaneous exams with different timings, apply extra time percentages to individual students, manage reading time periods, and synchronize all of this across every display device in your examination centre.
For schools running official examinations—IB Diploma, GCSE, A-Level, Cambridge IGCSE, AP, and similar qualifications—the software needs to handle the specific requirements of these exam boards while remaining flexible enough for internal mock examinations.
The Five Problems That Plague Exam Coordinators
Before evaluating any exam display system, understand the problems that consistently cause issues during examination periods.
Problem One: Multi-Device Synchronization Failures
Most exam centres use multiple devices displaying timing information. The main hall might have two large screens, the extra time room has its own display, and the medical room needs a separate screen for students with rest break accommodations.
When these devices show different times—even by 15 or 20 seconds—you create compliance issues. Examination boards require consistent timing across all candidates. A student glancing at two different screens showing different remaining times loses confidence in the examination process.
The root cause is typically how the software handles data synchronization. Systems that save display information locally and then attempt to sync to the cloud will always have lag. The delay might be acceptable during setup, but during a live examination, any discrepancy is unacceptable.
Problem Two: Inability to Modify Sessions During Examinations
Mock examination periods are chaotic. Students fall ill and need to reschedule. A candidate arrives late and needs to be added to an already-running session. An access arrangement gets updated mid-week, changing a student's extra time from 25% to 50%.
If your exam display software prevents you from adding papers to existing sessions, or locks student arrangements once the session is created, you're forced into workarounds. Creating entirely new sessions, running parallel displays, maintaining manual backup records—all of which increase error rates.
The software should support full editing capabilities throughout the examination lifecycle. If you can't modify a running session, the system wasn't designed for real examination environments.
Problem Three: Inadequate Individual Student Timing
Students with access arrangements don't fit neatly into group timings. Consider a student with 25% extra time who also has supervised rest breaks entitlement. They need:
- Their personal end time calculated with the extra time percentage
- The ability to pause their individual timer during breaks
- Accurate tracking of total break time for audit purposes
- Resume functionality that correctly extends their end time
Many systems force coordinators to create separate "sessions" or "arrangements" for each such student. This fragments the examination management, makes oversight difficult, and creates opportunities for errors.
Proper individual student timing requires per-student state management—not just per-exam timing.
Problem Four: Reading Time Complexity
IB Diploma examinations include mandatory reading time before writing begins. Other examination types have similar requirements. The reading time period needs to:
- Display separately from writing time
- Transition smoothly into the main examination
- Apply correctly to students with extra time (reading time itself typically doesn't attract extra time, only writing time does)
Systems that conflate reading time with examination time, or that can't handle the transition properly, create confusion for both invigilators and candidates.
Problem Five: Offline Reliability vs. Sync Accuracy
Examination halls don't always have reliable internet connectivity. Display devices need to function if the network drops. But offline capability often conflicts with synchronization accuracy—if devices operate independently when offline, they can drift apart.
The technical solution requires careful architecture. Devices should calculate timing from timestamps rather than storing countdown values. This means all devices independently calculate the same result from the same starting data, maintaining accuracy even during network interruptions.
Essential Features for Any Exam Display System
Based on these problems, here's what to evaluate in any exam display software.
Real-Time Cross-Device Synchronization
Test this before committing to any system. Make a change on one device and time how long it takes to appear on others. Anything over two seconds should concern you. For critical examination settings, sub-second synchronization is the standard you need.
The underlying technology matters. Systems using real-time database subscriptions (like those built on Supabase or Firebase) can achieve instant sync. Systems that poll for updates periodically will always have lag.
Complete Session Editing
Verify that you can perform all of these operations on an active session:
- Add new papers or examinations
- Remove papers that are no longer needed
- Add students mid-session (for late arrivals)
- Modify student extra time percentages
- Change student access arrangements
- Adjust start times for individual students
If any of these are blocked after session creation, the system will force workarounds during your busiest periods.
Per-Student Timing Controls
Each student should have independent timing state. This means:
- Individual pause and resume buttons for rest breaks
- Automatic end time extension when breaks are taken
- Visible break duration tracking for audit purposes
- Break history maintained for compliance documentation
Students with rest breaks should remain visible on the main display alongside their peers—not hidden in a separate session.
Comprehensive Extra Time Support
The system should handle common extra time percentages (10%, 25%, 50%) and allow custom percentages for unusual arrangements. Extra time calculations should:
- Apply automatically to base examination duration
- Display clearly on both coordinator and public displays
- Handle correctly when combined with reading time
- Update immediately if the percentage is modified
Multi-Room Management
Schools often run examinations across multiple rooms simultaneously. The software should support:
- Multiple distinct displays, each showing room-appropriate information
- Centralized control from a single coordinator interface
- Independent display settings (colours, zoom levels) per room
- Shared examination data across all displays
Offline Operation
After initial setup, displays should function without continuous internet connectivity. However, offline mode should not sacrifice timing accuracy. Look for timestamp-based timing calculations rather than stored countdown values.
Exam Board Integration
Pre-loaded examination templates for major boards (AQA, OCR, Edexcel, Cambridge CAIE, IB, College Board) save significant setup time. The system should include:
- Correct durations for all components
- Appropriate reading time where applicable
- Updated information when exam board specifications change
Technical Architecture That Matters
Understanding why some systems fail helps you evaluate alternatives more effectively.
Why Local-First Architecture Fails
Traditional software saves data to the local device first, then syncs to the cloud. This approach made sense when internet connectivity was unreliable, but it creates fundamental synchronization problems.
When Device A saves a change locally and attempts to sync, and Device B does the same thing simultaneously, the system must reconcile conflicting states. This reconciliation takes time and sometimes fails. The 15-20 second delays coordinators experience aren't bugs—they're inherent to the architecture.
Why Cloud-First Architecture Works
Modern systems save data to a cloud database first, then notify all connected devices of the change. Every device receives the same update at approximately the same time. There's no reconciliation needed because there's only one source of truth.
The potential downside—dependency on internet connectivity—is addressed through timestamp-based calculations. Devices don't store "time remaining: 47 minutes." They store "exam started at: 09:00:00, duration: 120 minutes." Any device can independently calculate the current state from these immutable values.
Why Timestamps Beat Countdowns
Storing countdown values seems intuitive. "This exam has 47 minutes remaining" is how humans think about time. But countdown values must be continuously updated, creating constant database writes and synchronization traffic.
Timestamps are immutable. "This exam started at 09:00:00" never needs updating. Every device calculates current remaining time independently: current_time minus started_at minus total_pause_duration equals elapsed_time; duration minus elapsed_time equals remaining_time.
This approach achieves:
- 97% fewer database writes
- Perfect cross-device accuracy
- Reliable offline operation
- Instant synchronization when connectivity returns
Evaluating ExamClock
ExamClock was built specifically to solve the problems outlined in this guide. Here's how it addresses each concern.
Instant Synchronization
ExamClock uses Supabase real-time subscriptions for immediate cross-device updates. Changes appear on all connected displays within milliseconds, not seconds. The architecture eliminates sync delays by design, not through optimization of a flawed approach.
Full Mid-Session Editing
Every element of an examination session remains editable throughout the examination lifecycle. Add papers, modify student arrangements, change extra time percentages, handle late starters—all without creating new sessions or workarounds.
Individual Student Management
Each student has independent timing state. Pause one student for a rest break while others continue. The paused student's end time extends automatically by the exact break duration. Break history is maintained for compliance documentation.
Reading Time Handling
Reading time displays separately and transitions smoothly into writing time. Extra time applies correctly to writing time only, matching IB Diploma and similar examination board requirements.
Offline-Capable, Sync-Accurate
ExamClock uses timestamp-based calculations throughout. Displays remain accurate during network interruptions and resynchronize instantly when connectivity returns. You get offline reliability without sacrificing sync accuracy.
Comprehensive Exam Templates
Pre-loaded templates cover 1,600+ examinations across 26 qualification types from major boards including AQA, OCR, Edexcel, Cambridge CAIE, IB, and College Board AP. Templates include correct durations and reading times, updated when specifications change.
Transparent Pricing
ExamClock costs $79 per year for a standard subscription. No hidden fees, no per-device charges, no contact-us-for-pricing opacity. Schools know exactly what they're paying before committing.
Implementation Checklist
When implementing any exam display software, follow this checklist to avoid common problems.
Before Purchase:
- Test multi-device sync with your actual network conditions
- Verify all editing operations work on active sessions
- Confirm per-student pause/resume functionality
- Check that your exam boards and qualification types are supported
During Setup:
- Configure display settings for each examination room
- Set up user accounts with appropriate permission levels
- Import or configure extra time arrangements for known students
- Test offline operation by disconnecting network temporarily
Before Each Examination Period:
- Create sessions using pre-loaded templates where available
- Add students with access arrangements
- Verify display visibility from all candidate positions
- Conduct a timing accuracy test across all devices
During Examinations:
- Monitor synchronization status
- Handle late arrivals through mid-session student additions
- Manage rest breaks using individual pause controls
- Document any timing adjustments for compliance records
After Examinations:
- Export audit logs for compliance documentation
- Review any timing incidents
- Update student arrangements for future sessions
Making the Decision
Exam display software is a small investment relative to the stakes involved. A timing error during official examinations creates compliance issues, appeals, and potential re-sits. The cost of unreliable software far exceeds the cost of reliable software.
Evaluate systems against the problems outlined in this guide. Test synchronization under real conditions. Verify that mid-session editing actually works. Confirm that individual student timing meets your access arrangement requirements.
Then choose the system that solves your actual problems—not the one with the longest feature list or the most impressive marketing.
ExamClock provides instant synchronization, full mid-session editing, and individual student break management for schools running IB Diploma, GCSE, A-Level, Cambridge IGCSE, and AP examinations. Start with a free trial at examclock.com.
Key Takeaways
- Multi-device synchronization failures stem from local-first architecture; cloud-first systems with real-time subscriptions eliminate sync delays
- Inability to edit running sessions forces error-prone workarounds during examination periods
- Per-student timing state enables proper rest break management without fragmenting sessions
- Timestamp-based calculations provide both offline reliability and sync accuracy
- Pre-loaded exam templates for major boards (IB, Cambridge, AQA, Edexcel, OCR, AP) reduce setup time and errors
- Transparent pricing allows budget planning; avoid vendors who hide costs behind "contact us" barriers
