EWASHINGTON
Projects

EduDrop

A lesson that drops onto every student's screen, with no internet.

AndroidAny browserPrivate repository

Snapshot

Status
In development · v0.1
Teacher
Android phone or any laptop
Students
Any browser, no app
Class size
30+ students
Distribution
Signed APK via Obtainium
Built with
Kotlin · Ktor (CIO) · WebSocketsPure-JVM routing enginecommonmark · pdf.jsPlain HTML, CSS & JS
Overview

EduDrop is a classroom tool that needs no internet, no accounts and no student app. The teacher runs a lesson like a playlist from their phone or laptop, and each Block of it (a prompt, a task, a worksheet) appears in every student's browser the moment they press Dispatch. A Block can go to the whole class, to two halves with different versions, or out to jigsaw groups, and students tap Done so the teacher can see where each group is. It all runs over the local Wi-Fi, from a server on the teacher's own device.

The concept

Group work in a classroom usually means printing different sheets, or projecting one thing and asking half the room to ignore it. EduDrop lets the teacher decide, Block by Block, who sees what. Students scan a QR code, type their name and get whatever their group should be looking at, and it changes when the teacher moves on.

Broadcast

Everyone sees the same Block. The default for instructions, prompts and whole-class discussion.

Split A/B

One Block with two versions of the same material. Half the class gets A, half gets B, and each student only ever sees their own.

Jigsaw

The classic expert and home groups. Students study one topic in an expert group, then regroup so every home group has one expert per topic.

The problem and its constraints

The idea is simple. What made it hard is where it has to run: a room of 30 or more mixed devices, on a network nobody controls, often with no internet at all.

30+ students at once

A real class, not a small group. Every student needs the right Block within a second of the teacher pressing Dispatch, and the teacher needs to see who's done.

A phone hotspot tops out at ~10

The obvious setup, the teacher's phone as hotspot and server, was measured at about ten connected devices. Fine for a small group, a third of a class.

School Wi-Fi often blocks it

Many school and guest networks stop devices talking to each other. The teacher's own browser works and nobody else can connect, and no app can work around that.

Any device, browser only

Android and iOS phones, tablets, laptops, old and new. No student app, no accounts, no logins. Whatever is in the student's hand has to be enough.

No internet at all

No internet means no TLS certificates, no CDNs and no secure-context browser APIs. Every script, style, font and PDF viewer is served by EduDrop itself over plain HTTP.

Devices drop out constantly

Phones sleep, iOS Safari suspends the page when it's locked, and Android kills background apps, including the teacher's server. Reconnecting has to be the normal, cheap path.

How it was conceptualised

The plan was reviewed before any code was written, and every choice was logged with why it was made, what it rules out and how hard it would be to undo. A few of those choices shaped everything after them.

  • The riskiest parts went first: the server, the routing and the network. The interface came last and was treated as replaceable, so no time went into screens that a failed network test would make pointless.
  • The server is Kotlin, so the same code runs on a laptop for the prototype and unchanged inside an Android app for the real thing. A Node server would have had to be rewritten or awkwardly embedded later.
  • Which device runs the server and which device provides the network are treated as separate questions. The first choice is the Wi-Fi the class already shares; when that's missing or blocks devices, a pocket travel router; a phone hotspot is for small groups only.
  • Broadcast, Split and Jigsaw are all the same thing underneath: one group, two groups, or N groups. One code path meant all three modes were built and tested together rather than Broadcast first and the rest bolted on.
  • Every update sends each student their whole current view, not a change. A reconnect is just "send me the latest", which removes a whole class of out-of-sync bugs on flaky connections.

Testing the assumptions

There was no school to test in, so each assumption got the cheapest test that could prove it wrong: a measurement on real hardware, a throwaway spike, or a simulated class.

  • Hotspot capacity: measured on a real phone at about ten devices. That one number moved the design away from "the phone does everything" to supporting shared Wi-Fi and a travel router.
  • Can a phone even be a server? A spike put a Ktor web server inside an Android foreground service, installed it on a phone and opened the page from another device. The WebSocket round trip worked, so the rest of the server was built on it.
  • Can it handle a class? A simulator runs 36 fake students over real sockets who join late, disconnect and rejoin at random, and mark Blocks done, then checks every view against the engine. It was mutation-checked: dropping one push in five makes it fail.
  • Does a crash lose the class? The server was killed with kill -9 mid-lesson and restarted. Groups, names and progress all came back, because state is written to disk after every change.
  • Does the jigsaw come out fair? Tests for every class size from 1 to 40 found the first design sent every leftover student to the same home group, six in one and four in the others. It now deals students out with one running counter, and group sizes never differ by more than one.
  • Still to prove: a full lesson on a real iPhone, an Android phone, a tablet and a laptop together, and how many students one phone can serve when it is on a router rather than a hotspot. The prototype is only as trustworthy as those tests.

From prototype to app

The prototype ran on a laptop, deliberately unstyled, to prove the routing and networking before anything else. Because the server was already Kotlin, the app is that same server running inside Android, with the teacher page grown into the main interface.

Prototype: a laptop server

A Kotlin server on a laptop with bare, unstyled pages. The teacher gets Prev and Dispatch, a roster with groups and Done counts, and a QR code of the server's own address. Students type a name and get the current Block and a Done button.

App: the same server on Android

The prototype server moved into the APK as a foreground service. The app's window is the teacher page in a WebView, so the phone and a laptop browser share one interface, and "Open in browser" stays for big screens.

Lessons are Markdown

A lesson is a Markdown file, or a folder or zip with its files. Teachers can write them by hand or with the Block editor, which works with no class running and nothing on the network.

Questions and timers

A Block can carry one question: polls, quizzes, word clouds, short answers and exit tickets, plus an optional timer. The teacher sees the responses come in live.

Files and PDFs

Lessons carry worksheets and images, and the teacher can share a file live to everyone or one group. A built-in PDF viewer is served from the app, because Android Chrome downloads PDFs instead of showing them.

Groups organiser

Class lists and a group maker that mixes or keeps together by the teacher's own columns, with pairs kept apart or together. Groups can be planned before the lesson, and students tap their name to land in their planned group.

Join with a QR code

The server finds its own address on whatever network it's on and shows it as a QR code. No typing addresses, no .local names that Android browsers can't resolve.

Android phonesiPhonesTabletsLaptopsFully offline

Teacher guide

A 9-page guide to writing lessons and asking questions: the lesson file format, the four modes, every question type, timers, getting students connected and a complete worked example.

Download the Lesson Guide (PDF, 673 KB)

Colour

Blues and whites, and nothing else. The student page is a single card with big buttons, so it reads on a cheap phone in a bright room. Light or dark follows each device until the person picks, and every student chooses their own. The icon is a white drop, one lesson, landing on a line, the class, on a blue rounded square.

  • Primary #2563EB
  • Primary, dark mode #4F8DFF
  • Icon gradient #3B82F6
  • Soft blue #E3ECFF
  • Ink #0F1B33

Highlights

  • Crash recovery asks nothing. If Android kills the app mid-lesson it resumes the same class on restart, keeps the teacher's link working, and students walk back in without retyping their names.
  • Students are never identified by IP address. Behind a travel router every student can look like the same address, so identity lives in a session id stored on the device.
  • Differentiation tags on class lists stay on the teacher's device. They are never sent to student pages, never put in exports, and hidden on the class page by default, because that page is often on a projector.
  • The lesson editor listens on the phone's own loopback address only, so a teacher can build lessons on the bus with no Wi-Fi and nothing visible to anyone else. The class server only goes on the network while teaching.
  • Only files a lesson actually links to are served, so pointing at a lesson in Downloads never publishes Downloads. Zips are read by entry name and checked, so a hostile zip can't write outside its folder.