Help

Help

Updated October 24, 2026

Results and your students' data

Your students used an app and you want to see what they did — and, when the time comes, to clear it. Each published app has tabs for exactly that, and you're the only one who sees your classes' results.

Where do I see what my students did?

Open a published app's page and choose the Results tab, then pick a class. You get a table of the students in that class by the things your app saved for each of them, shown as plain text. A value too long for the cell has a Show all button. Only you see your own classes' results.

What's the Leaderboard?

If your app keeps a score, the Leaderboard tab shows the top 50 for the class, best first, with each student's nickname and when they posted. Apps that use named boards get a picker to switch between them. An app that keeps no score has nothing here.

Can I download the results?

Yes — Download CSV on the Results tab gives you one row per student (and a row for anything saved for the whole class), which opens in any spreadsheet for your gradebook. The file is named after the app, never the class.

Done looks like: the CSV opens in your spreadsheet with a column for each thing your app saved.

What does “What this app stores” show?

It lists the kinds of thing an app has saved for a class — the keys it uses, how many students, how big, and how long KiteQuad keeps it for your account — but never the saved values themselves. It's the place to check what an app is collecting before you hand it to more students.

How do I delete a student's data, or a whole app's?

On the Results tab, a student's row menu has Delete their data; a student who has left the class but still has data saved is listed under the class with the same button, so you can reach them after a move. To clear a whole class, use Delete this class's data on the same tab; to clear everything the app saved, use Delete all under “What this app stores”. Each asks first and can't be undone. A student using the app right now can start saving again straight away.

Done looks like: the rows you deleted are gone, and the student can keep using the app.

A student reported an app, or an app tried to leave. What now?

Both show on the app's Reports tab. A student's report gives the reason in words; a “tried to leave” note means the app started to open another page and KiteQuad closed it — network access from apps is blocked, and leaving the page is one of the other things we watch for and tell you about. We email you too (a count and a link, never a student's name or anything they saved). Open the app in preview, fix what the note points to, publish, and press Resolve. KiteQuad doesn't take an app down over a report by itself.

How do I delete my KiteQuad account?

In Settings, under Delete my account, type your handle to confirm. From that moment students can't open your apps, and your classes, students, apps and their data are scheduled for deletion. Everything is deleted for good within 7 days, and our backups keep a copy for about 30 days after that, then it's gone from them too. We email you when it's done. There's no undo.

Deleting your account doesn't uninstall the KiteQuad app from your GitHub account if you connected one — see How do I stop publishing from GitHub?.

Done looks like: you're signed out, students can't open your apps, and you get an email when the last of it is gone.

Scripts in your pages

Your AI tool wrote the app's code into the page itself, and you'd rather not open the file to change it. You don't have to: the check moves those scripts into files for you when you publish, and tells you if anything might work differently.

Why does the check say it moved my scripts into files?

AI tools usually write an app's code straight into the page, between <script> tags. When you publish, KiteQuad copies each of those scripts into a file of its own in a folder called _inline, and the page loads it from there, in the same place and the same order. That lets the page run under a stricter safety rule, which closes one way an app could get around KiteQuad's protections. The page keeps each script's text too, so a page that shows students its own code still shows it.

You don't need to change anything. An app can have up to 300 different scripts written into its pages; past that the check stops it and gives you a prompt to put the code in a few script files instead. Your upload can't have a folder of its own called _inline.

The check says “A script may work differently”. What should I do?

Open the app in preview and try the part the note names. A few rare kinds of code notice the move: a short timer that expects a later script on the page to be there already; code that adds a module script and uses it straight away; a file loaded with jQuery's $.getScript that declares its names with let, const or class (or starts with "use strict") when the code uses those names the moment it loads; code that finds other files from its own script's address; and, on a page with Babel scripts, a plain script that waits for the page to finish loading. Code that adds an ordinary script and uses it straight away, as $.getScript usually does, works as before. If the part the note names works, publish as usual. If it doesn't, paste the note's prompt into your AI tool and upload what it gives you.

Done looks like: the report's note is gone, or the part it names works in preview.

What does “This page keeps its scripts inside the page” mean?

KiteQuad couldn't move every script of that page into files for certain, so it left the page as it was. It works the same for students, under the older, looser safety rule every page had before; network access is still blocked there, as on every page. The usual reason is an import map (<script type="importmap">) the check can't apply ahead of time, for example because the code builds an import() address while it runs. Libraries KiteQuad copies into your app, such as three.js and its add-ons, don't cause this: the check rewrites the names they import. The note says why, and when there is something you could change, it gives you a prompt; when there isn't, it says so.

Publish from GitHub

You keep an app's files in GitHub, and every change means downloading a zip and uploading it again. Link the app to its repository instead: each push to the branch you pick becomes a new version, checked the same way as an upload before any student sees it. KiteQuad only reads your app's files from GitHub and tells GitHub whether a version went live; GitHub gets nothing about your students.

No GitHub card in Settings? Then publishing from GitHub isn't switched on yet. Uploading and pasting an app work as always.

How do I connect my GitHub account?

Open Settings and press Connect GitHub. GitHub asks where to install the KiteQuad app: pick your own GitHub account, then all your repositories or only the ones your apps live in, public or private. GitHub sends you back to Settings when it's done.

A GitHub account connects to one KiteQuad account. To add repositories later, press Connect another account or add repositories in the same place.

Done looks like: Settings says “GitHub is connected” and lists your GitHub account under GitHub.

Can I connect my school's GitHub organization?

Not yet. Only a GitHub account of your own connects: if you install the KiteQuad app on an organization, Settings says so and doesn't connect it. Keep the repositories your apps publish from on your own account.

We plan to let a school's admins attach its GitHub organization once school accounts arrive. That isn't built yet.

How do I link an app to a repository?

Open the app's page and find Publish from GitHub. Pick the GitHub account, the repository and the branch. In Folder, type the folder your app's index.html is in, or leave it empty if it's at the top of the repository. Several apps can publish from different folders of one repository. Then press Link repository.

Linking doesn't publish anything by itself. Push to the branch, or press Pull now to bring in what's already there.

Done looks like: the app's page says “New versions come from” with your repository, branch and folder.

What happens when I push?

We download that commit from GitHub, take the linked folder, and check it exactly as we check an upload: the same limits and the same rules. The app's page lists the commit under Latest from GitHub and updates by itself while the check runs. Students keep seeing the live version until a new one is published.

Only the branch's newest commit goes live: if a newer push comes in while a commit is being checked, the older one is skipped. A push that changes none of this app's files (a change in another app's folder, or a README outside the app's folder) makes no new version and shows “No changes”. If you link the whole repository, every file in it is part of the app, its README included, so editing the README makes a new version.

When does a push go live by itself?

When Publish by itself is on (it starts on) and the check found nothing that needs your OK. That means no problem to fix, and anything it asks you to confirm (that a form doesn't ask students for anything that identifies them, or that you know what happens when a student presses a link to another website) you already confirmed on the live version, for the same things in the same files. One more of them than before, and the push waits. Warnings that need no confirmation, such as a picture from another website that won't load on KiteQuad, don't hold back a push to an app that's live.

Otherwise the new version waits on the app's page and we email whoever linked the app. It waits, for example, when the check found something that must be fixed, when there's something new to confirm, when Publish by itself is off, or when an app that has never been live gets anything but a clean check, warnings included. A push never puts back up an app you took down. To publish one that waits, press Review this version on the app's page.

What does the check on GitHub mean?

Each commit on GitHub shows this app's result under a name of its own, kitequad/publish (…); the app's page shows the exact name. Apps that publish from one branch each show their own.

• Checking this commit in KiteQuad means the check is running.
• Published as version N means it's live.
• No changes: version N is live means nothing in the app changed.
• Waiting for your review in KiteQuad means it's waiting on the app's page.
• Blocked: … means something must be fixed in the repository before it can go live, or KiteQuad has blocked the app. The words after “Blocked” say which.
• Skipped: … means a newer commit was pushed or published, or the app now publishes from somewhere else.
• KiteQuad couldn't check this commit (or a library couldn't be downloaded) means the check didn't finish. When GitHub or a library's website was briefly unavailable, it tried again by itself first, three tries in all. Press Pull now to try again; if the app's page says GitHub refused to send the files, check first that the KiteQuad app on GitHub can still see the repository.
• KiteQuad couldn't read this commit's files means the files GitHub sent for this commit couldn't be opened, so nothing was checked. Pull now downloads them again.

On a public repository anyone can read these. They carry only these words and a link to your dashboard: never your app's student link, and nothing about your students.

What does Pull now do?

Pull now on the app's page checks the newest commit on the linked branch straight away, as a push would. Use it after linking, when a check says to try again, or to bring the branch's newest commit back after a rollback. If that commit was already checked and nothing has changed since, it says “Already up to date”.

Done looks like: the branch's newest commit shows under Latest from GitHub as Published, or waiting for you.

I rolled back. Will my next push undo it?

Not unless it changes the app. A push that changes none of this app's files leaves the version you chose live, and GitHub shows “No changes to this app: version N stays live”. A push that does change the app's files publishes as usual, by itself if Publish by itself is on, so turn that off first if you want each new version to wait for you. To put the branch's newest commit back, press Pull now: it goes through the check and goes live the usual way, even over your rollback. All of this is the same for a version you uploaded by hand.

Which files do you skip?

A repository's own housekeeping files are left out quietly and never served to students: the .git and .github folders, and files named .gitignore, .gitattributes, .gitmodules, .gitkeep, .nojekyll, .editorconfig, LICENSE, LICENCE, COPYING or CNAME, in any folder and in capitals or not. So are the leftovers computers add to zip files (__MACOSX, .DS_Store, Thumbs.db), from any upload. Everything else, README.md, LICENSE.md and .env included, is checked like any other file.

What can't it do?

• Build your project. We take the files in the folder as they are. If your app needs a build step (a React or Vite project, say), commit the built files and link the folder they're in.
• Take a repository over 25 MB. GitHub sends the whole repository even when you link one folder, so the whole repository's download has to be under 25 MB, the same limit as an upload. Give a big app a repository of its own.
• Connect a school's GitHub organization (above), or GitHub Enterprise Server.

How do I stop publishing from GitHub?

Press Unlink on the app's page. New pushes stop reaching the app; the live version and its history stay as they are. Uninstalling the KiteQuad app on GitHub, or taking a repository away from it, unlinks the apps that publish from it in the same way.

Deleting your KiteQuad account unlinks every app too, but it doesn't uninstall the KiteQuad app from your GitHub account: it keeps the access you gave it to your repositories until you uninstall it in GitHub's settings, under installed GitHub Apps. The delete screen in Settings says so, with a link.

Done looks like: the app's page no longer says “New versions come from”, and pushes to the branch change nothing.

Your plan, and your school's questions

Your district wants paperwork before a new tool goes in front of students, and IT wants to know what to unblock. Here's where each answer lives, and what KiteQuad costs while it's in beta.

Does KiteQuad cost anything?

Not during the beta. Every teacher has all of Teacher Pro's limits at no cost, and Settings shows it under Plan and billing. There's nothing to pay and no checkout yet. Paid plans come after the beta, and we'll email you well before anything changes.

When a plan changes, nothing you made is deleted. If you then have more apps live than the Free plan allows, you get 7 days to choose which stay live; the others are taken down from students, not deleted, and every version you published during the beta is kept.

My school's review asks for a privacy policy and security details. Where are they?

All of it is linked from the trust center: the privacy policy with how long each kind of data is kept, the terms, a COPPA notice for schools, the companies that process data for us and what each one gets, a security overview, an accessibility statement, and our answers to the K-12CVAT vendor questionnaire as a page and a spreadsheet. A page marked “Draft — under review” is still being reviewed by a lawyer before launch.

What does my school's IT team need to allow?

Send them the IT kit. It lists the addresses to allow for students and the one for teachers, and the camera setting badge sign-in needs. Student pages load no outside fonts, analytics or tracking scripts, so there's nothing else to allow.

Done looks like: a student signs in on a school Chromebook and opens one of your apps.

How does an app save my students' progress?

With kitequad.store, the small toolkit every app on KiteQuad gets. The SDK docs show how, and have a copy-paste KiteQuad-ready prompt: give it to your AI tool with your request, and what it builds saves progress this way and avoids the few things that don't work here. A test copy of the toolkit lets you try the app on your own computer before you publish.