Privacy Policy
Last updated: 16 November 2026
The app runs on your device. Your questions, libraries, whiteboards, scores and student roster are stored in your own browser and stay there unless you deliberately sign in and turn on sync.
You can use every feature of this app without an account, without Google Sign-In, and without an internet connection.
We do not run advertising. We do not build profiles. We do not sell, rent, lease or share personal information with anyone, for any purpose.
On our website, and only there, the app counts a few things anonymously — which pages open, how many quizzes are started, how many hints or readings are opened — so we can see what is actually used. No cookie, nothing stored on your device, no identifier that outlives the page, never a name or anything you typed. It is off in K-12 mode, off if your browser sends Global Privacy Control or Do Not Track, and one switch turns it off (see “Anonymous usage counts” in section 3).
1. Who this is for
This is a mixed audience application, built for tutors, teachers and students. It is not directed primarily at children.
Signing in with a Google Account is strictly optional, and every feature works without it. That matters beyond convenience: Google's API Services policy prohibits applications directed primarily at children from using Google Sign-In, and the optional-account architecture is what keeps this app correctly positioned as mixed audience.
If you are a student under 13, you do not need an account and should not create one. Nothing about taking part in a lesson requires you to sign in.
2. What stays on your device
By default, this is everything:
| Data | Where it lives |
|---|---|
| Quiz libraries and questions | Your browser's local storage (synced only if you turn sync on) |
| Missed questions, questions marked for review (since 5 October 2026), per-topic progress, item statistics | Your browser's local storage |
| Per-skill mastery scores, and the per-question difficulty and ability estimates fitted from your answers | Your browser's local storage |
| Your own quiz scores | Your browser's local storage (a score line syncs only if you turn sync on) |
Study settings, your light/dark theme choice (theme), and how you like to practise vocabulary — scoring, question style and session length (geoVocabPrefs_v1, since 26 September 2026) | Your browser's local storage |
| Whiteboards and their pages | Your browser's local storage |
| Annotations saved with a quiz attempt — including the other participants', after a live session | Your browser's local storage — see below |
| Handwriting recorded during a live session — yours and the other person's strokes, per question, with their timings, so the lesson can be watched back | IndexedDB, on your device, for 30 days, then deleted automatically — see below |
| A solution you keep from a recording (since 15 November 2026): the handwriting of the person who made the recording, per question, so the question can show a Video chip after it (or that part of it) is answered. Only that person's own strokes; the other person's (a student's) are dropped before anything is stored. Strokes and timings only | IndexedDB and a small list in localStorage, on your device only. Not synced, not in a share link or an export, not sent in a live session. Kept until you remove it, replace it, or delete the library |
| Imported PDF page images | IndexedDB, on your device |
| Class rosters and student names you type | Your browser's local storage |
| Group Jam class results the teacher chooses to save | Your browser's local storage — see below |
| Assigned practice you have been given, and results waiting to be handed in | Your browser's local storage — see below |
| Local account credentials and 2FA secrets | Your device only |
| A count of how far you got in the first few minutes, and whether live sessions connect | Your browser's local storage — see below |
| A copy of the last few quizzes you deleted, so you can put one back | Your browser's local storage — see below |
Your own word lists in My Decks — each card's term, definition, hint and section, unfinished rows you have not completed yet, and each card's review schedule (geoDecks_v1, geoDeck_<id>_v1, geoReview_deck-<id>_v1; since 3 October 2026) | Your browser's local storage, never synced and never uploaded — see below |
| A vocabulary practice session in progress — the words, how far you have got with each, and your points — so a reload does not lose it (since 26 September 2026) | This browser tab's temporary storage (sessionStorage), gone when the tab closes; nothing you typed is kept past the answer it was marked on |
My Decks never leave the device by themselves (added 3 October 2026). A deck you build or import — from a paste, a Quizlet or Anki export, a spreadsheet or a pack file — is read in your browser and kept in its local storage. It is not part of sync, it cannot be shared by link, and it is never sent to our server or to anyone else. Practising it keeps a review schedule beside it (when each card is next due), and that schedule is always kept for a deck, whatever the Review queue setting says for libraries. Export writes a file to your device — the cards, and your review progress only if you leave that box ticked; where the file goes after that is your choice. Delete removes the deck, its unfinished rows and its review schedule at once; there is no copy kept to restore it from, so export first if you might want it back.
Exports for other drill platforms stay on your device too (added 4 October 2026; Blooket and Kahoot 5 October 2026). “Export for Quizlet, Anki, Gimkit, Blooket or Kahoot” — on a deck, on a quiz’s cards, on a quiz, and as a review set on the results screen — makes a file on your device or puts text on your clipboard: questions, answers and wrong answers, or terms and definitions, and nothing about you (a review set is ordered by what you missed, but carries no name, score or date). Nothing is uploaded from here. Importing that file into Gimkit, Blooket, Kahoot, Quizlet or Anki is something you do on their site, under their own privacy policy, not this one. The Blooket file is a CSV and the Kahoot file a spreadsheet (.xlsx), both built on your device, with no author, company or date inside them.
Deleting a quiz keeps a copy on your device for a little while, so that deleting the wrong one is not permanent. When you delete a quiz, the app holds a copy — its questions, its title, and where it sat — and offers to put it back from a line under your shelves. It exists because the alternative is a one-click action with no way back.
Three things about it, plainly:
- It never leaves the device. No network path, no server table, and it is not part of cloud sync even when sync is on. A deletion you made is a deletion everywhere; only the local copy remains, and only here.
- It is small and it forgets. The last 10 deleted quizzes, and fewer if they are large — there is a size ceiling too, and the oldest drops off first. It is an undo buffer, not an archive.
- You can empty it whenever you like. "Recently deleted" →
Forget these, or
MasterBank.forgetRecovery()in the console. Putting a quiz back also removes its copy. Nothing here survives clearing your browser storage.
There is deliberately no timer. A copy is not deleted on a day nobody chose; it is displaced when you delete more, or removed when you say so. That is the same bargain the annotation ring buffer makes, and it puts the decision with the person who made the deletion.
The same place also keeps a change that did not finish saving. Since October 2026 a large library is stored a quiz at a time, and if a save is interrupted part way (the browser closed mid-write, say), the app puts the library back to its last complete save and keeps the quizzes from the unfinished one here, marked as repaired, rather than losing them. A notice says so and links to them. They follow every rule above: device only, the same ceiling, forgotten when you say so.
A library two copies of the app both changed keeps the other version for 30 days. For a while after that change, an older copy of the app — a browser tab left open since before an update, or a desktop install not yet updated — can still edit a library this copy has also edited. When both have changed it, yours stays as it is and the other version is kept whole, on this device only, so that neither change is lost. A notice offers Open the older copy, which opens it as a separate library to compare.
- It never leaves the device, and is not part of cloud sync.
- One per library, and it has a timer, unlike the copies above: it is a whole library, so it is deleted automatically after 30 days, as soon as you open it, when you delete it under Settings → Device storage, or when the library itself is deleted for good.
Group Jam results a teacher saves stay on the teacher's device. During a live Group Jam session, each student's score reaches the host's device directly over the peer-to-peer connection — that is how the game works, and our server is never in that path. When the session was launched from a class roster, the host can press "Save results" on the results screen. That is the only way a session's results persist, and what is kept is deliberately reduced: each student's total score, correct/incorrect counts, accuracy, a per-topic summary, and who was absent. The per-question answer log is discarded at the moment of saving and is never stored. Saved results live in the teacher's own browser storage, are never uploaded, have no table on our server, and are deletable one session at a time, per class, or by deleting the class. They are labelled — in the app and in any exported spreadsheet — as practice results reported by each student's own device, not invigilated grades. A session not launched from a class roster cannot be saved at all.
Typed answers are numbers, and the app cannot accept anything else. Since 23 August 2026 a question may ask you to type a number rather than pick an option. What you type is treated exactly as a picked option already was: it stays on your device, it is discarded with the rest of the per-question log whenever a result is recorded, and there is no column for it on our server — a synced score line carries totals only, never what you answered. In a live session it crosses the same direct peer-to-peer connection a picked option does, and our server is not in that path either.
The reason this box is safe to have at all is that it is not a text field.
What it accepts is a closed grammar — digits, at most
one decimal point or one fraction bar, an optional leading sign, and a short
length limit. Since 14 October 2026, on questions that take an exact value or
a rounded one, it also accepts arithmetic: + − × ÷, powers,
brackets, and the three words sqrt, cbrt and
pi, so that a student can type sqrt(46). Since 8 November 2026
it also accepts the letter e, Euler's number, as the calculator
does. No other word can be
entered. A name, a sentence, an email address or a web address cannot be
entered, so an answer box cannot become somewhere a student's identity ends up
by accident. That is a deliberate design constraint rather than a side effect,
and it is enforced by the same code that decides whether the answer is
right.
In a live lesson, the other screen can also see what is being considered before it is submitted (added 29 August 2026): the ticks made on a select-all question, for a typed answer the draft number, shown as a faint “considering” note, and — on a put-in-order question (added 25 September 2026) — the order the steps are in, as they are moved. That arrangement is only a sequence of step numbers, the same thing the answer itself is once submitted. Since 4 October 2026, an algebra answer being typed is shown the same way: only once it already reads as a maths expression in the question’s own letters (the check a submitted answer must pass), at most 200 characters — so a word, a name or a half-typed bracket is never sent, only the fact that typing is happening. On a sketch-the-graph question, the marks placed on the graph so far, and the curve drawn so far, are shown the same way: their positions in the graph’s own units, the type chosen for each point (for example “local max”), and each stroke of the curve as points in the same units, sent when the stroke ends — the same data a submitted sketch carries, at most 40 marks and 300 points of curve. This travels over the same direct peer-to-peer connection everything else in a lesson does; our server never sees it, and nothing about it is stored anywhere. The closed-grammar rule above still holds with no exception: a half-typed entry that does not yet form a valid number is never transmitted — the other screen is told only that typing is happening, not what the characters are. These signals exist only during the live connection, expire within seconds (an arrangement within a minute), and are discarded, not recorded.
Each screen also tells the other how wide it is (added 8 November 2026), so the wider one can mark where the narrower one ends and neither person writes where the other cannot see. What crosses is two whole numbers: the slice of the question's column the window shows, in the column's own units. It describes a window, not a person, travels over the same direct connection, and is not stored.
Questions marked for review are shared in a live lesson (added 5 October 2026). In a one-to-one lesson both screens show the same marked questions: what crosses is a question’s id and whether it is marked, over the same direct peer-to-peer connection, never through our server. A mark that arrives from the other screen is shown for the lesson only — it is never saved on the receiving device, which keeps only the marks its own user made. Nothing about who marked what is recorded.
Flashcards can be followed in a live lesson (added 26 September 2026). When a student opens flashcards during a lesson, the tutor's screen shows the same card and whether it is turned over. What travels is the card itself — words from the quiz or the vocabulary deck, never anything the student wrote — plus its position in the deck. How the student rated a card (Again, Hard, Good or Easy) is not sent: that self-assessment stays in the student’s own browser, in the review schedule it feeds. It goes one way only: nothing on the tutor’s screen can turn the student’s cards. It crosses the same direct peer-to-peer connection as the rest of the lesson, our server never sees it, and nothing about it is stored on either side.
Assigned practice stays on your device until a lesson is already running. A teacher can hand out a link that carries a set of questions plus two study preferences — guided pathway and spaced review — and a due date. That link travels from teacher to student and contains no information about any student: no name, no class identifier, no roster entry, no teacher identity.
When you complete assigned practice, the result is written to your own browser storage and nowhere else. It is not uploaded, it has no table on our server, and it is not sent anywhere at the moment you finish. It waits. The next time you join that teacher's live session, it is handed over the same direct peer-to-peer connection the session already uses — so no new connection, no account, and no server are involved at any point. If you never join another session, it simply stays on your device and nothing is ever sent.
A quiz run as an assessment records LESS, not more. A quiz
opened as a test — the link carries assess=1 — behaves the
same way in every respect this policy describes, with two subtractions. It writes no
entry to the spaced-repetition review schedule on your device, even if that feature is
switched on, and it creates no in-session re-insertion state. Your score, the questions
you missed and your topic totals are recorded exactly as they are for ordinary practice,
and go exactly as far — which is to say, no further than they already did. Nothing
about a test is sent anywhere that ordinary practice is not, and no new record exists
because of this mode.
What is kept and handed over is the same reduced summary a live session produces: totals, correct and incorrect counts, accuracy, and a per-topic summary. The per-question answer log is discarded when the result is recorded and is never stored or sent. Results waiting to be handed in are visible to you in the app, and clearing this site's data removes them.
A diagnostic sends less about you than it knows. A skills check works out which topics you can already do, which one you are ready for next, and which are still out of reach. That full picture stays on your device. What is handed to your teacher is deliberately narrower: the topics you are ready to learn next, by name, because that is what a teacher acts on; counts only for how many topics you have already mastered and how many the check could not settle — numbers, never a list of names; and how many questions the check used, with the note explaining that the result is a position within your teacher's own material and not a grade level.
The list of topics you cannot do yet is never sent. It is the largest part of the result and it is the part a teacher cannot act on, so it stays on your device. The record of which individual questions you were asked, and how you answered them, is discarded when the result is recorded — exactly as for ordinary assigned practice. Diagnostic results travel by the same route and only by it: they wait on your device, and are handed over the direct connection the next live session already opens. Nothing is uploaded, and there is no table for them on our server.
On the teacher's side, a returned result is stored with that class's records at the moment it arrives — the deliberate acts here are assigning the work and opening a session for the class, so the hand-in completes without a further click, and the student's device is told it arrived so it can stop holding a copy. A session with no class attached refuses hand-ins entirely, and the work simply stays on the student's device. What the teacher's device stores is the same reduced summary, attributed to the class-register entry the student's typed name matched (or held under the typed name, visibly, when nothing matched — the app never guesses). It stays on the teacher's device until deleted — per assignment, or with the class — is never uploaded, and is labelled as self-reported practice in the app and in any exported spreadsheet, exactly like live session results.
"Your browser's local storage" means localStorage, and — once a
profile approaches what localStorage allows — IndexedDB
in the same browser. Both live only on your device: moving data between them
changes which drawer it sits in, never whether it leaves the machine. The app
also keeps a verified backup copy of your content in IndexedDB as
protection against running out of space. Quota problems are reported on
screen, to you, and nowhere else.
There is no telemetry of your content and no background upload — and no crash reporter unless you turn one on: an anonymous, scrubbed error report you can opt into is described in section 3, and it is off by default in every mode. Signed out, this app never sends your content to a server. The one thing the website sends without being asked is the anonymous usage counts described in section 3 — counts of what was used, never content, and never from the desktop app or a USB copy.
The app counts a few things about itself, on your device, and sends none of them. Two small tallies exist so the people building this can tell a confusing first five minutes apart from a broken one: how far a new user got (opened it, looked for content, added content, ran a quiz) as counts and dates — never a record of what you added or teach — and whether live sessions actually connect. Both live in local storage and have no network path at all: no endpoint, no request, no identifier, no beacon, and no opt-out to forget to use, because there is nothing to opt out of. They are not analytics; an analytics system reports somewhere, and these have nowhere to report to. If you want to tell us how you got on, run Activation.report() in your browser console and read the result — it prints plain text, and you decide whether to send it.
Since 22 August 2026 there is a button for the live-session half of that. The session panel offers Copy diagnostic — in the notice shown when a session ends, and in the panel footer while one is running. It puts the connection timings from your device on your clipboard so you can paste them to the person you were connected to, which is almost always a tutor asking why the lesson would not connect. The button sends nothing itself: there is still no request and no endpoint, and nothing moves anywhere unless you choose to paste it. What that text can carry is deliberately narrow, and the narrowness is enforced in code rather than promised here. It carries the stage names and millisecond timings of each connection attempt, which family of browser and operating system you are using, and the running count of attempts and successes. It carries no session code — a session code is a live key to a room that is still joinable, so it is removed — and no name, no email address, no web address, no question and no answer. Fields are permitted by a short list rather than blocked by one, so a field added later cannot escape by being forgotten; the build searches the finished text for each of those things and fails if one appears.
Since 2 November 2026 that text also carries a short connection log. While a live session is open, your browser keeps on your device the last 60 moments of the past 12 hours: when the connection's state changed (words such as "connecting", "connected" or "failed"), when it opened and closed, which side closed it and how long it had lasted, when it went quiet, when the page was hidden, shown or left, when a tutor's page told the student's it was about to move to another page (since 11 November 2026; the moment only, never which page), and a student's steps in joining (an invite link opened, Join pressed, and whether looking up the code worked, failed or timed out — never the code itself). Each entry is a time on your own device's clock, a fixed word, and those few numbers and words, held to the same short list as everything above. Nothing sends it by itself. When a student's browser connects, the record it sends the tutor's browser (see "Connection timings travel the same way" below) includes this log without the moments the student's page was hidden, shown or left: when a student switched away is their own business, and it leaves their device only in a report they copy themselves.
Since 16 November 2026 it also carries a few counts about how the connection was attempted. For each attempt: how many ways in each side's browser offered, by kind (on its own network, or through its public address), and, when an attempt fails, how many pairs of those were tried, how many checks were sent, how many were answered and how many were heard from the other side. They are there to tell a network that will not let two browsers reach each other from a page that had gone. They are numbers only: no network address, no port and nothing that identifies a network is recorded, and the build checks that an address cannot travel under one of those names. Like the timings, they are in the report you copy and in the record a student's browser sends the tutor's when it connects.
Since 13 November 2026 your browser also notes when a page stopped responding. If a page of this app is busy with one piece of work for two seconds or more, your browser keeps, on your device, when that began, how long it lasted and how long the page had been open: three numbers, the last 20 of them, on every page and not only in a live session. It says nothing about what you were doing or which quiz was open. It exists because a page that freezes looks, from the outside, like a failing connection or failing storage. Nothing sends it by itself. It is part of the report you copy; during a live session it is also one of the page moments in the connection log above, and like those it is not in the record a student's browser sends the tutor's. Safari does not offer this measurement, so on Safari nothing is kept.
Since 21 September 2026 the same report is one tap away wherever you are, not only inside the session panel: Copy diagnostic report sits under the ink toolbar's Settings and in the header's tools menu on every page. It puts the text above on your clipboard together with a few facts about the device and the app's own state that a tutor needs to make sense of a problem: which family of browser and operating system, the size of the screen and of the visible area, the pixel density, whether the pointer is a finger, whether the app is installed, the name of the page (never its address, and never anything after it — a share link or a session code can live there), the colour theme, the role you hold in a live session if any, whether a whiteboard tab is open and what the ink layer reports about itself, and the storage adapter's state: its mode, whether it has finished loading, its pressure level, and how many entries have moved to the browser's larger store — a count, because the entries' names carry your library identifiers and those stay home. Since 11 October 2026 it also says whether the browser has agreed to keep this site's storage ("persistent storage"), and, when the larger store was found emptied from outside the app, the verdict and how many entries were missing — counts again, never the entries' names. Since 13 November 2026 it also says, of the unfinished quizzes this device is keeping so you can pick them up again, how many there are, how much room they take, how many are stored compressed, and how old they are — numbers only, never which quizzes or what is in them. Since 14 November 2026 it also says how many entries the app has set aside after the store stopped answering, how its last try at reading them went, and how long ago this device last finished a sync: counts and times only. Since 27 October 2026, when the browser's larger store has failed, it also carries the short record the app keeps on your device of that store's last 20 failures (when, at which stage, and the error's type name, never its message), whether only a reload of the page can help, the missing entries counted by kind (each entry's leading word, such as geoLibraryQuizzes, which names what an entry holds and never which library), and how many repairs the app's read checks have made and when the last was. Since 29 October 2026 it also says, for the first of those failures on a page, what else the store was still working on at that moment (each by the same leading word, with how many entries, how large and for how long), how much room the app's offline copies of its own files take (per copy: how many files, how many bytes, and how many are a page address, never which), and the names of this site's databases (a name only when it is made of letters, such as sedAppStorage). Your library names, quiz titles, questions, answers, storage entry names and the raw browser string are none of them in the text, and the build checks each of those absences against the finished report. It sends nothing: there is still no request and no endpoint, and the text moves only when you paste it.
Imported PDFs are converted in your browser. The file is never uploaded. This is deliberate: a tutor's PDF is often a student's marked work or a school's own paper, and rendering it on a server would put student records into a third party's logs purely to save some processing on your machine.
3. What reaches our server, and only when
Our server receives data only in the situations below, all of them optional.
When you sign in with Google
We store, for the account holder only: an opaque Google subject identifier, your email address, your display name and, if you set them, a chosen handle and an avatar (at most 16 characters, such as an emoji, that you choose; we never fetch your Google picture). If you sync your libraries and reorder them, we also store that order, so it follows you to your other devices: a list of library ids and the time you set it, with no names and no content. We never receive your password, and we request no access to Gmail, Drive, Calendar, Contacts or any other Google service.
Sessions are stored as a hash of a random token, never the token itself, so a database disclosure does not hand anyone a working login. A session expires 30 days after it was last used: on the website each refresh replaces the token with a new one, and the old one stops working.
Passkeys (optional). If you add a passkey to your account, we store its public key and credential id, the counter your device increases on each use, when it was created and last used, and a label you type to tell your passkeys apart (at most 60 characters; please do not put a student’s name in it). The private half never leaves your device. Adding or using a passkey briefly stores a one-time random challenge, with your account id when you are adding one; it is deleted as soon as it is used, and within 5 minutes regardless.
What every request to our server carries, and the server’s logs. Our server runs on Cloudflare, which, like any web host, receives your IP address and the network details of every request. The server keeps a log record of each request in Cloudflare Workers Logs, for operational diagnostics and security. A record holds the request’s address and method (the address can include a room, share or lesson-link code, but never the key of a secure lesson link: that key sits after the # in the link, which browsers never send), its response status, the request and network metadata Cloudflare attaches (which may include your IP address, approximate location and browser details), and any error or status note the server writes (for example that a sign-in was renewed after a lost cookie), which never contains your content or identifies you. Cloudflare deletes these records after 3 to 7 days, depending on our plan. We do not copy them anywhere else, and they are not used to identify, profile or follow anyone.
On the website (not the desktop or USB app), staying signed in uses one strictly-necessary cookie, named quiz_refresh and scoped to interactivequizapp.com. It holds only that opaque session token — never your name, email or any content — is marked HttpOnly so no script on the page can read it and Secure so it travels only over HTTPS, and is used for nothing but keeping you signed in. It is not a tracking cookie, sets no advertising or analytics identifier, and lasts 30 days from its last refresh or until you sign out. The desktop and USB copies cannot use a cookie and keep the token in the app’s own storage instead.
When you turn on sync
Signed in and syncing, three kinds of content are uploaded so they reach your other devices: your whiteboards, your quiz libraries — the quizzes you have written or imported, their topic structure, the order you have arranged them in, and a library's mark (the single letter or emoji beside its name, capped so short it cannot hold a name) — and your own practice score lines, described below. The first two also carry merge bookkeeping: per-item edit timestamps and a random per-device identifier, which is how two of your devices that both edited offline combine their changes without losing either side's work. The identifier is random characters with no connection to your account, your hardware, or you. The server stores all of it as opaque text and does not read the content of it — with one precise exception. When two of your devices edit the same library while offline, the server resolves the collision, so the outcome is the same whichever device syncs first. To do that it works with the structure of your library and its merge bookkeeping: which quiz and question entries exist (their identifiers), their order, and which side's edit timestamp is newer. The content of your questions — the text, the choices, the answers, anything you typed — is copied through as opaque units the server never parses, compares, or logs; an automated test fails our build if the merge code ever names a content field, or if replacing every piece of content could change any merge decision. The overwritten side of a collision is returned once to the device that synced, for its local restore list, and is kept nowhere on the server. Whiteboards are not merged this way; they remain fully opaque.
A short summary is kept beside each synced library (since 13 October 2026). It is four numbers about the library: how many questions it holds, how many quizzes, its size in bytes before compression, and a fingerprint (a SHA-256 hash) of its content. A fingerprint is a fixed string of 64 characters that changes whenever anything in the library changes. It cannot be turned back into the content. Its job is to let your device ask "is the account's copy the same as mine?" and "how many questions does the account hold?" without downloading every library to find out, which is what Download from my account and the sync safety check used to have to do. Since 14 October 2026 sync asks the first question too, once per sync, by reading the account's summaries (not the libraries). A library whose fingerprint already matches is not uploaded again, so less leaves your device than before. When the answer is unclear, the library is uploaded as it always was. Your device works out the summary while it prepares the library for upload, and sends it with the library. The server works out its own only when it resolves a collision (above), from the merged library it is already holding. It counts quiz and question entries and hashes the text as a whole; it reads no question's content to do so. The summary is no more identifying than the library beside it. It is kept for exactly as long as the library, and deleting the library or the account deletes it.
A library’s description is not uploaded unless you ask for it. When you create or edit a library you may write a short description of what it is for. That text stays on your device. It is free text, so it could easily name a student — “Jimmy’s algebra remediation” — and we will not make that decision for you. If you want descriptions on your other devices, there is a switch: Settings → Privacy → Library descriptions, off in every account mode, including on a device set to “Independent tutor”. Turning it on uploads the description of every library to your account from then on, and the app says so in those words before you do. Turning it back off stops descriptions leaving from that moment; like every other sync switch, it does not reach back and delete what is already in the cloud — clear the description text itself, or delete the library, to do that. While the switch is off your device neither sends descriptions nor accepts one that arrives from somewhere else, so there is no state in which you have turned this off and a description still appears.
How often your device talks to the server, and what it says when it does. Syncing happens on its own: when the app opens, when you sign in, a few seconds after you change something, when you return to the tab, and — while the app is left open — on a timer you control, set to every 15 minutes by default. That timer only asks. It uploads nothing: it sends an empty list and the question "has anything changed since last time", and on the ordinary answer of "no" it receives an empty reply. Your content still goes up when you actually change something, which is the moment it should. The timer pauses while the tab is in the background, and can be set to 5 minutes, an hour, or off entirely in Settings → Sync. Like any request, it reaches our server with the network metadata, and leaves the short-lived log record, described under “When you sign in with Google”; it carries no content of yours.
You can turn each kind off separately. Settings → Sync has a switch for libraries, for whiteboards, and for your own score lines. Your account mode sets the starting position of each, and a switch you change yourself overrides it — including turning something back on that your mode had off, in which case the app says so at the moment you do it rather than afterwards. Turning one off stops that kind of content leaving from then on; it does not by itself remove what is already on the server, which you can do at any time by deleting the content or the account.
Everything else that can send anything is on Settings → Privacy (since 19 August 2026), so the whole answer to "what leaves my device, and how do I stop it" lives on two adjacent tabs: the account mode that sets the defaults, a switch for share-link uploads (off: the Share buttons refuse to upload; opening links other people send you still works), and a switch for hosted AI (off: only the on-device model remains). Every switch on both tabs resolves through the same single policy the sending code reads, so the panel cannot say one thing while the app does another. The same tab shows what is using your device's storage and carries the export, recently-deleted, and delete-cloud-copy actions.
K-12 classroom mode narrows this in code, not just in settings. With the mode on: whiteboards and practice score lines are not uploaded at all, short share links cannot be created (received links still open), and AI features run only on-device — no text reaches a hosted model. The one content path that remains is your own quiz libraries, with the warning above unchanged. These limits are enforced at the code paths themselves and asserted by automated tests on every build.
Know what this means. If you write a student's name on a whiteboard, import a PDF of their marked work, or type a student's name into a question, and sync is on, that content is on our server. If that is not appropriate for the material in front of you, keep sync off — the app is fully functional without it.
Your own practice history — a score line, and only yours. A quiz you took while signed in to this account syncs as a score line: which library and quiz, the quiz title, when you took it, and how many you got right, wrong and in total. That is the entire row. It exists so your own practice on a laptop shows up on your desktop.
What makes an attempt eligible is decided before anything is sent, and the rules are deliberately strict:
- An attempt syncs only if it carries the id of the account signed in right now.
- An attempt recorded while signed out, or before this feature existed, carries no such stamp and is never sent — not now, and not after a later sign-in. Unattributable history is treated as though it might be a student's, because on a tutor's laptop it might be. There is no backfill and no "claim these as mine" prompt: both amount to asking someone to vouch for records they cannot actually check, and a wrong answer would upload a child's performance record.
- Attempts from a Group Jam seat, a student portal session or a class register do not travel this path at all.
- If two people have used the same device, neither one's attempts are sent under the other's account.
There is no column on the server for a name, a per-question answer or a missed-question list, so no fault in the app can put one there.
What sync still never uploads. Which questions were missed or marked for review, per-question answers, per-topic accuracy, item statistics, class registers, tutoring client records and session notes are not uploaded and have no table on the server. Anyone's results but your own stay on the device, in full. Syncing the questions is what makes a second device useful; the item-level record of how an identifiable learner performed is the most sensitive thing this app holds, and it stays where it was made.
When you create a short share link
Share links normally send nothing anywhere. A share link carries the quiz itself, compressed into the part of the web address after the # — and browsers never transmit that part to any server. Sharing a quiz that way is between you and the person you send it to, and it stays the default.
Vocabulary practice links work the same way, and have no short form. “Copy practice link” puts a deck’s words and definitions — and the ids of the course units each card belongs to, so the drill keeps topics apart — in the part of the address after the #, so a student who opens it plays the vocabulary drill without an account, without a copy of the library, and without anything being uploaded — there is no server copy, no expiry and nothing to revoke. The address names the library and quiz ids so the drill can file its review schedule in a library the student’s device already holds; on a device that does not hold it, nothing about the round is kept beyond the tab. Our anonymous usage counts record the page’s path only, never its query or # part, so the words cannot reach them either.
That breaks down for a large pack. A quiz with pasted diagrams produces a very long address, and mail clients wrap long addresses while course sites truncate them, so the link arrives broken. For those, you can choose to create a short link instead.
This is opt-in, one share at a time. Nothing is uploaded automatically because a pack got big. The long link is always built first and always offered; the short link is a separate button, shown only when the long one is at risk, next to a description of what it does. You must be signed in.
- What is uploaded: the quiz content — questions, answer options, explanations, hints, and any images pasted into questions — and, for a whole library, its vocabulary cards (each term, definition and hint) and the library's id, so the person you send it to can update the same library from a later link instead of getting a second copy. It is stored compressed, and the server does not read or interpret it.
- What is not: no scores, no attempt history, nothing about a student, and nothing identifying whoever opens the link.
- Anyone with the code can open it. There is no sign-in on the reading side, deliberately — the person you are sharing with may not have an account. The ten-character code is the secret, and it is random.
- It does not expire (since 13 November 2026). A short link works until you revoke it or delete your account. Before that date a link lasted 30 days after you last shared it; links that were live on 13 November 2026 were kept. Sharing the same pack again gives you the same link rather than a second copy (since 26 September 2026). This means the copy of the pack stays on our service for as long as you leave the link in place: revoking the link deletes the copy at once.
- Nothing is removed to make room. One account can hold 1,000 short links and 100 MB of them together. Past either, a new link is refused and the app says so; no link you made is deleted to fit it. (From 26 September to 13 November 2026 the limit was 50, and the link you had shared least recently was removed to make room.) Nothing about who opens a link is recorded.
- You can review and revoke them under Share & collaborate › Your short links: one at a time, a selection, or everything made more than 14 or 30 days ago. Deleting your account deletes every short link you have made straight away.
If you have typed a student's name into a question, that text is uploaded with it. The confirmation says so before anything is sent. If that is not appropriate for the material, send the exported file instead — that path never touches our server.
When you start a live session
Live tutoring is peer-to-peer. Ink, everything drawn during a session, and any quiz the participants share or edit together travels directly between browsers and never passes through our server. Shared editing of a quiz is off until the quiz's owner offers it and the other person explicitly accepts; accepting saves a copy of that quiz on the accepting device, which its owner keeps and can delete like anything else stored locally. A chat travels the same way, since 16 September 2026: a live session has a small chat beside the lesson — typed messages, a few quick reactions, and pictures you choose to send. Everything in it goes directly to the other person's browser over the same peer-to-peer connection as the drawing, never to our server, and it is not saved anywhere: the conversation lives in the browser tab and is gone when the tab closes or the session ends; a picture is shrunk on your own device before it is sent. A web address you type becomes a clickable link on the other person’s screen, and the link’s text is always the address itself — there is no way to write a link that says one thing and goes somewhere else, so what the other person reads is where they go. Links open in a new tab with the referrer suppressed, so the site you link to is not told which page of this app the click came from; our page addresses carry library and quiz identifiers, and this keeps them from leaking to a third party. Only ordinary web links (http and https) are made clickable; anything else stays as plain text. Your own drawings on a quiz a tutor is showing you stay on your device, and do not outlive the lesson (16 September 2026): when a tutor moves the lesson to another quiz your page is replaced and then brought back, and your own working used to be lost each time. The app now keeps a copy of your in-progress working so it is still there when you return — held in your browser tab’s own temporary storage, never sent anywhere, never written into any library, and discarded by the browser when the tab closes. Retention here is a property of where the copy is kept rather than of a clean-up step that has to run. When a session connects or reconnects, each side re-sends its own drawings on every question of the quiz on screen, not only the current one (11 October 2026): a page reloaded mid-lesson keeps only its own working, so the other person’s drawings used to come back for the question both were on and no other. Now each browser sends the other, directly over the same peer-to-peer connection, its own strokes for each question of that quiz, so a reloaded page gets the whole lesson back — including anything you drew on that quiz before the session connected, as the question on screen always has. It sends only drawings you made: never the other person’s back to them, never a whiteboard tab, and never drawings restored from a saved attempt (those stay held back, below). Nothing new reaches our server, and nothing new is kept. Connection timings travel the same way, since 1 September 2026: when a student's browser connects, it sends the tutor's browser a small record of how its last few connection attempts went (since 1 October 2026, also the most recent attempt that did not connect, even when later successful ones have pushed it out of that window, and since 4 October 2026 its slowest successful connection of the last day, kept the same way — one record on the student’s own device, replaced by a slower one or after a day), and of any mid-lesson interruption it recovered from — how long each step took, whether it connected or reconnected, and the browser family and platform (for example "chrome, android"). It carries no name, no room code, no answer and no lesson content, and it goes directly to the tutor's browser over the same peer-to-peer connection, never to our server. It exists so a tutor can see why a session failed to connect without asking the student to dig for it; it is kept in the tutor's browser tab only, is discarded when the tab closes or the next session starts, and leaves that tab only if the tutor chooses to copy the diagnostic and paste it somewhere. Since 25 September 2026 the record also says how the student’s page came to exist — whether it was opened, reloaded or reached with back/forward, how long it had been open, and whether the page before it in the same tab closed normally or was shut down by the browser — so a tutor can tell a browser that reset the student’s page from a network drop. The last of those is answered by a one-character marker the app keeps in the tab’s own temporary storage; it never leaves the device by itself, holds nothing about the person, and is discarded when the tab closes. Since 2 October 2026 it also says what in the app loaded the student’s page: following the tutor, the app’s own tab strip, or an app update. That is one word from a fixed list, or “unmarked” when nothing in the app did (a link, the Back button, a person). The word is left in the tab’s own temporary storage just before the app navigates, and is read and deleted by the next page. Like the rest of the record, it carries no address and no title. Annotations from a session are saved on both devices, and that changed on 14 August 2026: the drawings kept with a saved attempt now include the other person's, so a student keeps the tutor's worked explanation for the question it was drawn on and a tutor keeps the student's working; in a group room that means every participant's — the host's saved attempt holds each student's drawings, and a student who runs the quiz from their own library keeps the host's and their classmates'. They do not sync, ever — these drawings are held in local storage, and turning sync on does not upload them; the one way they can leave the device is inside a lesson summary you deliberately send, as a file or as an encrypted link whose key we never receive (below). They are not labelled with who drew them: the record of which participant made which stroke is deliberately discarded when the attempt is saved, and kept only while the session is live so the app can show you who is drawing. You can delete them like anything else stored locally. A lesson you never finish is saved too, from a few seconds after you start drawing on it — since 15 August 2026 — it used to be discarded unless you reached the results screen, which lost a whole lesson of annotation for anyone whose session simply ended, and that is what a tutoring hour normally does. It is saved while you work, not when you leave: the moments a browser gives an app on the way out are too short to compress a lesson of drawings, so waiting for one would mean losing the work of anyone whose tab was closed, crashed, or discarded by the browser. One record is kept per quiz and refreshed as you go. The same rules apply to it as to any other saved attempt, and it counts against the same bounded archive; finishing the quiz replaces it, so one lesson leaves one record. Reopening a saved attempt does not re-share it: drawings restored from your archive are shown to you and held back from anyone who joins a later session, because the app can no longer tell which of them were yours. Showing restored work to somebody takes a deliberate action. A saved attempt can become a lesson summary PDF: the summary — the score (or how far an unfinished session got), the questions to revisit, what to practise, and the worked pages — is composed entirely on your device and saved as a file there. Creating one sends nothing to any server; sending the file — an email to your student, a print-out — is between you and them, through tools of your own choosing. If you would rather send a link, the next section describes the one way a lesson summary can touch our server: encrypted on your device first, with a key we never receive. Because saved drawings are not labelled with who drew them, the summary shows the lesson's working without saying who wrote which stroke. A live session’s handwriting is recorded on your device, and only there, since 20 September 2026. While a session is connected the app keeps the strokes drawn on each question — yours and the other person’s — with the moments they were drawn, so either of you can watch the working back afterwards, stroke by stroke, at normal or double speed, and export the questions you choose as a file. What is kept is vector strokes only: no voice, no camera, no names, no account or peer identifiers, no room code, no typed text, no pasted pictures, and no answers. Text boxes and images are deliberately not recorded, because a text box is where a name gets typed and a picture can hold anything. Erasures and undo are recorded (since 20 September 2026), as the removal of strokes the recording already holds — nothing more than “these strokes went, at this moment” — so a replay shows what was actually on the board at each moment rather than a stroke its author had rubbed out. Only questions that were actually drawn on appear, and a session with no drawing leaves nothing. Each recording is stored in your browser’s IndexedDB with an expiry 30 days after the session and is deleted automatically by a sweep that runs when the app starts, when a new session begins and when the review screen opens; you can delete any recording, or all of them, sooner from that screen. Recordings never sync and have no server table, no endpoint and no sync path: the one way one leaves the device is the export button, which writes a file you choose to save. The moment a session ends, the panel tells you what was kept and offers to show or delete it. Since 14 October 2026 that holds on both screens. When one person ends the session, the other person's app is told, with a message that carries nothing but the fact, and a student is shown a “Session complete” card saying what was recorded on their own device. Before, only the side that pressed End was told. Since 22 September 2026 a recording also keeps where each stroke sat on the question — the position and width of the question column on the screen it was drawn on, three numbers per stroke, which describe a layout and nobody’s identity — so the replay can lay the strokes over the question itself. The question shown under them comes from a quiz or library already on your device; nothing is looked up anywhere else. A replay can also be saved as a video clip of one question or as a review sheet — a PDF of each question with its finished working — both made on your device and saved as files you choose, never sent anywhere. Since 13 October 2026 a clip is made by your browser's own video encoder in a second or two. A clip already made is kept in the page's memory so a second download is instant. It is never written to the browser's storage, and it is gone when the session ends or the tab closes. And a recording file exported earlier can be opened in the review screen, and paired with a quiz pack file when its questions are not on this device: both files are read in memory only and nothing from either is stored. What the server holds briefly is the connection handshake: a short room code, WebRTC connection descriptors, the host's display name, and — in a group room — the name each student types when joining.
A vocabulary game played together travels the same way, since 2 October 2026. When a tutor starts the vocabulary game during a live lesson, both people play one game on the same cards. The tutor’s browser sends the student’s browser the cards (each word, its definition and any hint), the game’s starting point, and each move as it happens: which tile was tapped, or the answer typed. A typed answer is sent only when it is submitted, and at most 64 characters of it, never while it is being typed. All of it goes directly between the two browsers over the same peer-to-peer connection as the drawing, never to our server. The student’s copy is kept in the browser tab’s own temporary storage and is discarded when the tab closes. On the student’s device the game records only the student’s own answers in their review schedule, and only in a library they already have. The tutor’s device records nothing from a game a student is playing.
Student names entered to join a room are limited to 40 characters and are automatically deleted 30 minutes after the student joins by an expiry sweep on the server. They exist only so a host can tell participants apart during the lesson. Students can join with an initial or a nickname; nothing verifies or requires a real name.
That 30 minutes is a hard limit for a student’s name, and renewing a session does not extend it. While a lesson is actually connected, the host’s device tells the server every ten minutes that the session is still live, so the room code and its connection descriptors survive a long lesson instead of expiring under it — up to a hard maximum of 4 hours from when the room was opened, after which the room is deleted no matter what. (Until 9 September 2026 only one-to-one rooms were renewed; a group room’s code went at 30 minutes.) A student’s typed name is deliberately excluded from any renewal and still goes at 30 minutes. The name runs on its own clock, and nothing can extend or restart it.
A student’s own connection record (their seat) is renewed the same way as the room when they change page, and — since 24 September 2026 — while they are still connected: the host’s device tells the server which students are connected right now, and only those records are renewed, so a student who works quietly on one problem for half an hour is not dropped on their next reconnect. A student who has left is not renewed. Either way it is never past the room’s own expiry and so never past the 4-hour maximum. The name inside that record is not renewed with it: 30 minutes after the student joined, their name — and the account handle, if the room required sign-in — is removed from the record while the connection details stay, and from that moment it is never served back to anyone, even before the sweep reaches the row.
A correction, 24 September 2026. Until that day the code did not do what the two paragraphs above say. When a student in a group room changed page, their name was renewed along with their connection details, so it stayed on the server for as long as the lesson ran — never past the 4-hour maximum, but well past 30 minutes. Separately, a tutor changing page in a one-to-one lesson could extend that room past its 4-hour maximum. Both were found in a code review, corrected the same day, and are now checked on every build by a test that runs the server’s real code against a real database and reads back what it stored.
When you send a lesson summary as a secure link
A lesson summary is composed on your device and saved as a file — that stays true and stays the default, forever. If you are signed in, you can additionally send one as a secure link. Because the summary's worked pages can contain a student's handwriting, this is the one place student work can touch our server — so it is engineered to arrive unreadable. It is encrypted before it leaves: the PDF is encrypted on your device with AES-256-GCM, using your browser's built-in WebCrypto, before anything is sent; what our server stores is ciphertext. We never hold the key: the decryption key is placed in the link itself, after the # — the URL fragment — and a fragment is never transmitted to any server by any browser. When your student opens the link, their browser fetches the encrypted copy and decrypts it locally, on their device. We cannot read what we store, and there is nothing we could be compelled to hand over that would change that: we hold ciphertext and no key. It is opt-in, one record at a time: creating a summary uploads nothing, and the link is a second, separate step behind a confirmation that says all of this. It expires after 7 days, automatically — deliberately shorter than share links, because this is a lesson handout in transit, not an archive; you can revoke it sooner from Attempt history, and deleting your account deletes every lesson link immediately. Anyone with the full link can open it — the link carries both the lookup code and the key, so treat the link the way you would treat the file itself and send it directly to your student. What is stored in clear is the quiz title, so your own revoke list is readable, and the timestamps; there is no field for a student's name. K-12 classroom mode does not create these links at all — the same code-level switch that blocks pack short-links blocks this, encrypted or not.
When you turn on anonymous error reports (off by default)
If the app hits a bug — a script error, a connection failure — it can send us a small crash report so we can fix it. This is off until you turn it on (Settings → Privacy → “Anonymous error reports”), in every mode, always.
What a report contains is a fixed list, not “whatever we find useful”: which build of the app was running; your browser family and major version (for example “chrome 128”) — never the full browser identification string; the error’s kind and its message after a scrubbing pass that removes web addresses, codes, keys, coordinates, and any quoted text that is not a code identifier; which of our own files and lines the error passed through — a frame from any other origin (a browser extension, another site) is recorded only as the word “external”; and, for connection failures, the names and timings of the connection steps reached — never the details inside them.
What a report can never contain: your name or anyone else’s, a student’s anything, your email, your IP address (used only to rate-limit the endpoint, never stored), the address of the page you were on, anything you typed, drew or imported, and any identifier that could link the report to you or your account. Reports are anonymous by construction — the table they land in has no owner column, which also means we could not look up “your” reports even if you asked: nothing connects them to you. The scrubbing is enforced by an automated test that plants a room code, a link key, a student’s name and drawing coordinates into constructed errors and fails our build if any of them would reach the wire.
Reports are deleted automatically after 30 days. Turning the switch off stops the very next report; at most five reports leave in any hour.
We ask once, and only on the website (since 25 September 2026). On your first visit to interactivequizapp.com, a small notice in the corner asks: “Help improve Interactive Quiz App — Automatically send crash and connection reports so we can make live lessons more reliable”, with Turn on and No thanks. Nothing is sent while the notice is showing, and nothing is sent if you ignore it or close the page: silence is a no (the notice comes back on a later visit until you answer). Your answer is kept on your device, in the browser’s storage as telemetryOptIn (“true” or “false”). It is the same setting as the switch in Settings → Privacy, so changing one changes the other, and once you have answered either way you are not asked again. The notice is never shown in K-12 classroom mode (a teacher can still turn reports on in Settings for their own device), when your browser sends Global Privacy Control or Do Not Track, in the desktop app, or in any copy of the app not served from interactivequizapp.com. Crash reports never go to the usage-count service below, whatever you answer.
Freeze recording (the operator’s own devices only)
On devices belonging to the person who runs this service, and only when they switch it on, the app notes which of its own functions were running when a page froze for two seconds or more: file, function name, line and time. It records no content, nothing typed, and no web address. The notes stay on that device, and leave it only if that person copies a diagnostic report by hand. It never runs on anyone else’s device.
(Added 13 November 2026. To make it possible, every page of the site is served with one more line, Document-Policy: js-profiling, which only permits a page to start the browser’s own profiler. The page starts it on those devices alone, and nothing is sent anywhere.)
Anonymous usage counts (on by default on the website; off in K-12 mode)
Since 23 September 2026, the website counts a few things so we can see what people actually use: a page opening, a quiz starting, a quiz’s first answer, a quiz being finished, a hint being opened, and a reading being opened. (Opening a reading, the short piece of the lesson behind a question’s Read button, was added on 14 November 2026. It says that one was opened, and nothing else: not which reading, not which question, and none of its words. The first answer and the finish were added on 25 September 2026, so we can tell a quiz that is abandoned before the first question from one that is abandoned near the end. They say that it happened, and nothing else: not which quiz, not which question, not whether the answer was right, and not a score.) The counts go to PostHog, an analytics service, on its EU servers. The code that sends them is a copy we host ourselves and have stripped to the minimum: it cannot record your screen or your clicks, cannot load anything else from PostHog, and every event passes an allowlist before it leaves.
What one event contains — the whole list:
- which of those five things happened;
- which page it happened on, as its address without anything after a
?or a#— so never a library, a quiz, a share link or a lesson key; - your browser family and version, operating system, and whether it is a phone, tablet or computer — never the full browser identification string, and never your screen size;
- a random number made up when the page opened, which is forgotten the moment you leave or reload it. It is the only id, and it cannot link one visit to the next;
- whether the page was in a live session at that moment (since 13 November 2026): yes or no, and nothing else. Not the session's code, not which side of it you were on, and not who the other person was. It lets us tell lesson use from everything else;
- the time, and the version of the counting code.
What it never contains: your name, your email, your account, a student’s anything, what you typed, drew or imported, your questions or your scores, where you came from, and no cookie — nothing is stored on your device for this at all. Your IP address is part of any connection to any server and cannot be hidden, so the PostHog project is set to discard it, and to not use it to work out a location.
When it does not run, and nothing is even downloaded:
- in K-12 mode (Settings → Privacy → account mode) — the mode for a class of minors;
- when your browser sends Global Privacy Control or Do Not Track — we honour both without asking you again;
- when you turn off Settings → Privacy → “Anonymous usage counts”;
- in the desktop app, a USB copy, a test copy, or any copy of the app not served from
interactivequizapp.com. - in a quiz embedded on another website (section 3h) — the counting code is not part of an embed at all.
- on the standalone placement check (section 3i) — the counting code is not part of that page either.
Why we do this, and the legal basis. To find out which parts of a free tool are used and which are not, so the effort goes where it helps. Under the GDPR and UK GDPR we rely on legitimate interests (Article 6(1)(f)): the counts are aggregate, identify nobody, and one switch stops them. You can object at any time with that switch or your browser’s privacy signal. For children, the counts carry no persistent identifier and no information about the child, and K-12 mode turns them off entirely (section 8).
PostHog keeps the events for the retention period of our PostHog plan — 1 year on the free plan, up to 7 years on a paid one — and a shorter period cannot be set. Because the events carry nothing that identifies anyone, there is also nothing we could find, export or delete for you individually; that is the design rather than an obstacle.
3h. A quiz embedded on another website
Since 4 October 2026, a quiz from one of our own bundled packs can be shown inside a page on another website, in a frame (/embed/). Only the sites we name in our server’s headers can do this — today that is kavatimes.org — and every other site’s frame is refused by the browser.
An embedded quiz is the quiz and nothing else:
- Nothing is sent anywhere but this site. It fetches the quiz’s questions from
interactivequizapp.comand that is all: no usage counts (section 3g does not run in an embed — its code is not on the page), no crash reports, no sign-in, no sync, no live session, no AI. The page’s own security policy forbids connecting anywhere else. - Nothing about the quiz is saved. Answers live in the open page and are gone when it closes; nothing is added to any library, and no attempt or score is recorded. Where the browser allows storage at all, the one thing kept is the app’s own storage-layer setting (
geoStorageMode_v1), which says nothing about the quiz or the reader. Browsers that refuse storage inside frames from another site — Safari does by default — run it exactly the same way. - The host website is told one number: the quiz’s height in pixels, as a message
{ type: "iqa:height", height: … }, so it can size the frame without a scrollbar. Never an answer, a score, a name, or which question is open. - The host website learns no more than any page that frames another: it chose which quiz to show. What a reader does inside the frame is not visible to it. In the other direction, the host site’s own analytics or cookies are the host’s, under the host’s privacy policy, and do not reach into the frame.
“Open in Interactive Quiz App” opens the full app in a new tab, where the rest of this policy applies as usual.
3i. A placement check opened from a link
Since 17 October 2026, a teacher or tutor can send a student a link to a short placement check (/diagnostic.html). It works out where the student stands in one set of material (what they have solid, what to learn next) on the student’s own device, with no account and no sign-in.
- Nothing is sent anywhere but this site. The page fetches its own questions from
interactivequizapp.comand that is all: no usage counts (section 3g), no crash reports, no sign-in, no sync, no live session, no AI. - Nothing is saved on the device. The page writes nothing to the browser’s storage at all and installs no offline copy. The answers and the result live in the open page and are gone when it closes. A reload starts the check again, which is why the page asks before you leave it in the middle.
- Scratch work stays on the screen. The page has a pen for working on the screen. What is drawn is kept only in the open page, is wiped when the next question appears, and is never saved or sent.
- The page never asks who the student is. The result names the check that was taken, the date and time, and the topics in each group, plus how many questions on each topic were answered right and wrong. It contains no name, no question text and no answers.
- The student decides whether the result goes anywhere. It can be downloaded as a file or printed. If they hand it to their teacher, it travels the way they choose, not through us.
3j. A link beside a reading
Since 15 November 2026, a reading shown beside a question (the Read pane) may carry up to four links chosen by whoever wrote the readings, for example to an interactive lab or a video.
- Nothing is sent until you click one. The app does not load, check or preview the linked page.
- A link can only go to a short list of sites: this site, stapleseducation.com, and YouTube (youtube.com, youtu.be). Any other address in a readings file is dropped when the file is read.
- Clicking opens that site in a new tab, and from then on that site’s own privacy policy applies. YouTube is a Google service and may set cookies and record the visit. The app tells the linked site nothing about you or the question you were on.
4. AI features, and what leaves the device when you use them
Three features use an AI model: generating questions, writing a study guide from a whiteboard, and checking questions for contradictions. All three are the only features that send your content to a company other than us, so they get their own section.
“Read aloud” is not one of them, deliberately. The speaker button beside a question uses the speech built into your browser, and it will only use a voice that runs on your device. Some browsers also offer network voices — Chrome’s “Google …” voices send the text to Google and send audio back — and this app will not use one. If your device has no local voice installed, the button tells you so and stays silent rather than sending the question anywhere. Nothing about reading aloud reaches us or anyone else.
Checking questions (“Check questions”, added 25 August 2026) is the newest of the three and is worth describing precisely, because it is the one that reads material you have already saved:
- It runs only when you press the button. There is no timer, no background sweep, and nothing is checked while you are away. If that ever changes it will be a separate, clearly-worded opt-in, because it would be a different promise from this one.
- Anything sent needs a second press, and that press names a number. The device-only checks below run first, on their own, and stop. Only then does the app ask whether to send anything, and the button says how many questions that is — “Send 12 questions to …”. Nothing has left the device at the point you are asked. Choosing to stop there keeps everything the device already found. If your backend is the on-device model, you are not asked at all, because nothing would leave.
- The app may notice that a library has not been checked in a while, and say so on the button. It works this out when you open a quiz — that is, when you are already here — and the only thing it does with the answer is print a sentence. Nothing is sent, nothing is scheduled, and no check starts on its own. A device nobody is using makes no requests, because nothing is running on it to make them.
- What it remembers, it remembers on your device only. Three small records, in your browser’s local storage, never synced and never sent: which flags you have marked as fine, a short fingerprint of the question text each of those decisions was made about (so a flag comes back if you later edit that question, and stays down if you do not), and the date a check last finished. The fingerprint is a short code derived from the text — it is not the text, and it is not reversible back into it.
- It is scoped to one quiz at a time, never a whole library.
- Most of it never leaves the device. Duplicate choices, two choices that are the same number written differently, arithmetic that does not come out, questions whose parts do not line up, and questions where more than one answer can be defended (an equation with two roots, both offered) are all decided in your browser by an algebra engine that runs there. No part of that pass involves a model or a network. Only one check needs a model — whether an explanation argues for a different answer than the one marked correct — and only the questions that check runs on are sent.
- What is sent for that check is the question text, its choices and its explanations, and nothing else: no topic, no difficulty, no provenance marking, no library or quiz name, nothing about you.
- The panel tells you how many questions were sent before you close it. When the answer is none, it says so.
You choose the backend, and the choice decides where the text goes:
| Backend | Where the text goes | Whose account |
|---|---|---|
| On-device model | Nowhere. It never leaves the browser. | — |
| Your Anthropic key | Directly from your browser to Anthropic | Yours |
| Your Google key | Directly from your browser to Google | Yours |
| Your OpenAI key | Directly from your browser to OpenAI | Yours |
| Bundled Gemini key | Directly from your browser to Google | The publisher's |
Three things follow from that:
- Nothing routes through our server. The request goes from your browser to the model provider. We never see the prompt or the answer.
- With your own key it is your account and your agreement with Anthropic, Google or OpenAI that governs how they handle the text — not ours. That includes whether they train on it: each states its own position for API traffic, and it is the one you agreed to when you made the key.
- Checking a key does not send your content. “Test & validate” beside the OpenAI key asks that provider which models the key can reach — the key, no prompt, no board text — and only when you press it.
- Question generation shows you the prompt before sending it. The extracted board text is loaded into an editable box first. Read it, and delete anything you would not hand to a third party.
- The study guide has no editing step, because it summarises the board as a whole. It names the provider in the dialog before it runs, and prefers the on-device model automatically when that is the working backend.
If the board has a student's name on it, and you generate questions or a study guide from it with a hosted model, that name goes to the model provider. Use the on-device backend, edit the name out, or don't use the feature for that board.
The brand kit
Your logo and colours are stored on this device only. They are presentation, not account data, so they are never uploaded and never synced.
A logo pointed at a URL on someone else's server would let that server see your
IP address on every page load. The app's security policy now blocks such a
fetch outright, in every copy — the hosted site, the portable folder, and
the desktop app all carry the same policy, so the image simply does not load. Use a
data: URL, which embeds the image on your own device; it is both the
private choice and the one that works. (This paragraph used to warn that the leak
was possible in copies run off disk. Since 13 Aug 2026 the policy travels with the
pages themselves, and the warning became a description of a blocked request.)
We never send anything to a model provider in the background, on a schedule, or without a deliberate action from you. There is no "improve our service by analysing your content" pathway of any kind.
Subprocessors
The complete list of third parties that can receive data through this app:
| Party | What they receive | When |
|---|---|---|
| Cloudflare | Hosting; the Worker and database in section 3 | Always for the website; server data only if you sign in |
| Google (Identity) | Authentication only | Only if you choose Google Sign-In |
| Google (Gemini) | The prompt text you send | Only if you pick a Gemini backend |
| Anthropic | The prompt text you send | Only if you pick the Anthropic backend |
| OpenAI | The prompt text you send; and, if you press “Test & validate”, your key alone with no prompt | Only if you pick the OpenAI backend |
| PostHog (EU cloud) | The anonymous usage counts in section 3 — no cookie, no identifier beyond the page, no content, IP discarded | On the website only; never in K-12 mode, under Global Privacy Control / Do Not Track, or with the switch off |
There are no others. No advertising network, no data broker, no email marketing platform.
Which providers this app can reach at all is a fixed list, enforced by the browser security policy shipped in every copy — hosted, portable and desktop. A request to anywhere else fails outright rather than being trusted not to happen, so adding a provider is a deliberate change to that policy, disclosed here in the same change.
5. What we never do
These apply to every user, and to anyone under 18 without exception.
- No targeted advertising. There is no advertising in this app at all.
- No commercial profiling. We do not build behavioural profiles of any user, and specifically not of students.
- No selling, renting, leasing or sharing of personal information. There is no "sale" or "share" as the CCPA defines it, so no "Do Not Sell or Share My Personal Information" mechanism is required. If that ever changed, this policy would change first and the link would appear.
- No tracking of people. No advertising pixel, no social widget, no session recorder, and no identifier that follows you from one visit to the next or from this site to any other. The one analytics component is the anonymous usage counting in section 3, which stores nothing on your device. The website sets exactly one cookie,
quiz_refresh, and only to keep a signed-in user signed in; it is strictly necessary, carries no identifier, and is absent entirely when you are signed out. - No use of student data for anything but the educational purpose it was provided for.
- No training of AI models on student data, or on yours. Nothing a student or you create, answer, draw or upload is used to train, test or build an artificial-intelligence model, ours or anyone else’s. Student privacy laws increasingly forbid this for student data (California’s, for one); we apply it to everyone. When you use an optional AI feature, what you send goes to the provider you chose, under the terms in section 4.
- No sensitive information asked for. Nothing in the app asks about a student’s health, sexual orientation, gender identity, immigration status, religion or any similar matter, and we do not want it. The app cannot stop someone typing it into a question or a whiteboard, which is one more reason that content stays on the device unless you sync it.
6. Data minimisation and retention
| Data | Retention |
|---|---|
| Live-session room codes and handshake data | 30 minutes, extended while a lesson is connected, 4 hours maximum |
| Student names typed to join a room | 30 minutes from joining, never renewed, then auto-deleted |
| Login sessions | 30 days after last use, then expired |
| Passkeys you enrol (optional) | Until you remove one, or delete your account. Only a PUBLIC key, with its label and use counter — the private half never leaves your device and we cannot read it |
| One-time passkey challenges | Deleted when used, and within 5 minutes regardless |
| Account record (email, display name, handle, avatar; the order of your library ids, once you reorder them) | Until you delete your account |
| Server request logs (Cloudflare Workers Logs, section 3) | 3 to 7 days depending on our plan, then deleted by Cloudflare |
| Synced whiteboards | Until you delete them |
| Synced quiz libraries | Until you delete them. A large one is stored in pieces: the same content, cut differently. A piece no current copy uses is deleted after the versions below that need it have gone, within 31 days; a piece from an upload that never finished, after 24 hours |
| Recent earlier versions of a synced library | 30 days, then auto-deleted; at most 24 per library, and at most one per hour |
| A backup folder you chose, if you turn it on | On your own computer, never uploaded. The last 7 daily copies; deleting the folder deletes them |
| A file you saved with “Save what’s only on this device” | Where your browser saved it, never uploaded. What this browser holds that your account does not; it is yours to keep or delete |
| Packs behind a short share link | Until you revoke the link or delete your account (since 13 November 2026; it does not expire). At most 1,000 links and 100 MB per account, past which a new link is refused and nothing is removed |
| Lesson summaries behind a secure link | 7 days, then auto-deleted; revocable sooner. Stored only as ciphertext — the key stays in the link and we cannot read them |
| Your own practice score lines (only with sync on) | Until you delete them, or your account |
| Anyone else's results, and all item-level detail | Never uploaded — device only |
| A copy of a quiz you deleted, or of a change that did not finish saving | Never uploaded — device only; the last 10, or fewer if they are large, then displaced oldest-first. Removed at once when you restore it or press "Forget these" |
| An older copy of the app's version of a library, after both copies changed it | Never uploaded — device only; one per library, deleted automatically after 30 days, when you open it, when you delete it under Settings → Device storage, or with the library |
| Group Jam results a teacher explicitly saves | Never uploaded — teacher's device only; kept until the teacher deletes them (per session, per class, or with the class) |
| Assigned-work results handed in to a teacher | Never uploaded — travel peer-to-peer during a live session, then teacher's device only; kept until deleted (per assignment, or with the class) |
| Anonymous error reports (only if you opt in) | 30 days, then auto-deleted. Anonymous — cannot be looked up or attributed |
| Anonymous usage counts (website only) | Kept by PostHog for our plan’s retention period — 1 year on the free plan. Nothing on your device at all. Anonymous — cannot be looked up or attributed |
| Handwriting recorded during a live session (strokes and their erasures) | Never uploaded — device only (IndexedDB); deleted automatically 30 days after the session, or sooner when you delete it |
| Everything stored only on your device | Until you clear it |
Deleting your account removes your user record, your sessions and passkeys, all of your synced boards, all of your synced libraries and their earlier versions, your practice score lines, every short share link and every encrypted lesson link you have created, and any live-session seat you hold while signed in, from the server in a single transaction.
7. Schools and FERPA
Where a school or district adopts this app, we act as a school official with a legitimate educational interest in the student data processed through it, under the direct control of the school with respect to the use and maintenance of that data. We use student data solely to provide the educational service, we do not re-disclose it, and we do not use it for any commercial purpose.
Schools requiring a signed Data Processing Agreement should request one before deploying the app to students. The local-first architecture means that in most tutoring use, no student record reaches our server at all.
Parents and eligible students may request review, correction or deletion of student data through the school. Requests made directly to us are answered within 45 days.
8. COPPA and children under 13
- The app collects no personal information from a child in its default, signed-out state. A student can be taught with it, take quizzes and draw on it without anything about them leaving the device. On the website, the anonymous usage counts in section 3 do leave the device, and we have designed them to fall outside what COPPA calls personal information: no name, no contact detail, no content, and no persistent identifier — the only id is a random number that dies with the page, and nothing is stored on the device to recognise it again. They are used only to understand and improve the app, never for advertising or to profile anyone. K-12 mode turns them off entirely, and that is the mode a school should use with a class.
- Where a school uses the app for a purely educational purpose and no commercial purpose, the school may consent on behalf of parents, as COPPA permits.
- Children should not create accounts. Google Sign-In is for the adult running the session.
- Parents may, through the school, review their child's data, have it deleted, and refuse further collection.
Written data retention policy
The amended COPPA Rule requires a written data retention policy, not merely a practice. This is it.
- Personal information is retained only as long as reasonably necessary to fulfil the specific educational purpose it was collected for.
- It is not retained indefinitely, and never for a secondary purpose such as analytics, model training or resale.
- Retention periods are the ones in the table above, and they are enforced in code rather than by policy alone: session-joining data carries a hard expiry timestamp and is deleted by a sweep that runs on the server, not by anyone remembering to run it.
- Data held only on your own device is under your control and is removed when you clear it. An older copy of a library, kept after two copies of the app both changed it, is also deleted by the app itself after 30 days (section 2).
- Account deletion removes the user record, all sessions and passkeys, all synced boards, all synced libraries and their stored earlier versions, all practice score lines, all share links and lesson links, and any live-session seat the account holds, in a single transaction.
Written information security program
Consistent with the amended COPPA Rule — effective 23 June 2025, with full compliance required from 22 April 2026 — we maintain a written information security program, scaled to the size and complexity of this service as the Rule permits. Its current commitments:
- Minimisation by architecture. Student-identifying data stays on the local device by default, and the server-side surface is deliberately small enough to audit in one sitting.
- Short retention. Session-joining data auto-expires in 30 minutes; a student’s typed name is never renewed past it.
- Credential hygiene. Session tokens are stored hashed. No client secret exists in the client. Passwords are never handled by the app in plain text.
- Transport security. All server communication is over HTTPS.
- Input treated as hostile. Content arriving from another person — an imported quiz pack, a joining student's name, a peer's drawing — is escaped before display and filtered against an allowlist where it must remain markup.
- Risk review on change. Every feature that creates, moves or exposes data about an identifiable student is assessed before it ships.
- Periodic testing. Safeguards are re-tested when the data surface changes, in particular the injection filters and the expiry sweeps.
- Annual risk assessment. At least once a year, and additionally whenever a feature changes what leaves the device, we review the data surface end to end: what is collected, where it travels, how long it lives, and who can reach it.
- Limits against abuse, and no untested deploy (since 25 September 2026). Every signed-in write is rate-limited per account, and every account has a storage ceiling for share links, lesson links and synced whiteboards, so one account cannot exhaust the service for everyone. The expiry sweeps run as independent steps, so one failure cannot stop the others. The site is not published unless the full automated test suite, including the tests that check these safeguards, passes on the exact build being deployed.
A designated person is responsible for this program. For a service of this size that is the operator named in section 12.
9. Your rights and choices
- Use it without an account. The strongest privacy control in the app, and it costs you no functionality.
- Keep sync off. Your boards, libraries and scores stay on your device.
- Turn off the usage counts. Settings → Privacy → “Anonymous usage counts”, or send Global Privacy Control / Do Not Track from your browser. Either stops them on that device before anything is downloaded.
- Export everything. Any library or board exports as a plain JSON file you own outright.
- Delete your account. Removes your record, sessions and passkeys, synced boards, synced libraries and their earlier versions, your practice score lines, any live share and lesson links, and any live-session seat you hold, from the server.
- Clear local data. Clearing your browser's site data removes everything the app has stored — provided the clear covers both stores. Your content lives in
localStorageand, as a verified backup and once a profile outgrows the smaller store, inIndexedDB. Some cleaning tools and privacy extensions clear only the first. When the app finds itslocalStorageempty and that backup still present, it restores your libraries automatically and tells you it has done so — because the overwhelmingly common cause is a tutor losing work they never meant to touch. Nothing is sent anywhere at any point; the restore is one drawer on your device refilling another. Some tools do the reverse and clear onlyIndexedDB; then whatever had moved into it is gone from this device, and the app says so rather than restoring anything on its own. If you sync, Download from my account offers to read it back from your account through read-only requests (since 13 October 2026, a list of your libraries without their content first, then only the ones this browser lost), after showing you what the account holds; it writes only the libraries this browser lost, sends no content, and makes no request at all while you are signed out. If you mean to erase your work, delete the libraries inside the app, or clear this site's data with site data/IndexedDBincluded. Deleting a library for good takes everything filed under it — its quizzes, scores, per-question statistics, mastery, review schedule, the whiteboard ink archived against its quizzes, the saved state of any quiz started and never finished (which can include a student's handwriting), and any older copy of it kept after a conflict (section 2). Since October 2026 that also holds when the deletion was made by an older copy of the app, which can leave the quiz-at-a-time storage behind: the next visit to the home page finishes the deletion. A library in Recently Deleted is not yet deleted for good: it keeps all of this so restoring it is lossless, and loses it when the 30 days run out or you empty the trash yourself.
Residents of California, Colorado, Connecticut, Virginia and other states with comprehensive privacy statutes have rights to access, correct, delete and port their personal information. Because we hold so little, most are satisfied by the export and delete controls in the app itself.
Those rights follow you, not us. State privacy laws attach to where the person is, so the list above applies regardless of where this service is operated from. We do not treat our own location as a reason to offer anyone less.
Complaints
If you are unhappy with how we have handled your information, tell us at the address in section 12, with “Privacy complaint” in the subject. We acknowledge every complaint within 30 days of receiving it, look into it without undue delay, keep you informed while we do, and tell you the outcome. This is the procedure the UK’s Data (Use and Access) Act 2025 requires from 19 June 2026; we offer it to everyone.
You can also complain to a regulator. In the UK that is the Information Commissioner’s Office (ico.org.uk), which expects you to raise the matter with us first; in the EU or EEA it is the data protection authority where you live. Complaining to us first never stops you going to them.
Where we operate, and the two Arizona laws that apply to us
Staples Education is a sole proprietorship operated by Adam Staples from Phoenix, Arizona, United States. Arizona has no comprehensive consumer privacy statute, which changes nothing about the rights above. Two Arizona laws do bind us directly:
- A.R.S. § 18-552 — breach notification. If unencrypted personal information we hold is breached, we must notify affected individuals within 45 days of determining it happened. Above 1,000 Arizona residents, the Attorney General and the credit bureaus are notified too.
- A.R.S. § 15-1046 — student data privacy. This binds operators of online services used for school purposes, and we are one. It prohibits targeted advertising built from information collected through school use, profiling a student for anything other than school purposes, and selling or renting student information. We comply with all three by construction rather than by policy — there is no advertising anywhere in this product, no profile is built about any student, and nothing about a student is sold or rented, because the answers do not leave the device to begin with.
10. Security incidents
If we become aware of a breach affecting personal information, we will notify affected users and, where student data is involved, the relevant school, without undue delay and consistent with applicable law.
11. Changes
Material changes are reflected in the date above and, where the change affects what leaves your device, surfaced in the app itself rather than only here.
12. Contact
Staples Education — [email protected]
For a Data Processing Agreement, a FERPA or COPPA question, or a data request, use the same address and say which it is.