
SPA vs. Hypermedia: A Collaborative Kanban Board Measured Against Planka
We built a Kanban board on which several people drag cards at the same time, rendered entirely on the server, and measured it against PLANKA on a slowed phone.
以下正文同步自 Hacker News 最新,版权归原站所有,已转换为易读排版。
We built a Kanban board on which several people drag cards at the same time, rendered entirely on the server, and measured it against PLANKA on a slowed phone.
Michael Bolli8 October 2026 13 min read
Why a Kanban board
The two apps
How the board stays in sync
How we measured
Loading the board
Moving a card
Adding a comment
Responsiveness and memory in the browser
Many people on one board
What runs on the server
Making a 200-card board fast on a phone
Limitations
When to choose what
Run it yourself
Measured 7 and 8 October 2026 · Playwright, Lighthouse 13.5, Chromium 154 · View source & raw data →
We built a Trello-style board on which several people drag cards at the same time, rendered entirely on the server: one Go binary, one SQLite file, Datastar in the browser. We measured it against PLANKA Community 2.2.1, a popular self-hosted Kanban app built with React, Redux, Sails.js and PostgreSQL. Both held the same boards, and the measured person used a slowed phone behind a 150 ms round trip.
Our board transfers 58 kB and is on screen after 0.6 seconds; PLANKA transfers 2.6 MB and shows its board after 15.4 seconds. A dropped card is in its new place after 252 ms, already accepted by the server; PLANKA shows the move after 481 ms and has the server's confirmation after 712 ms. Our board never shows a move the server hasn't accepted. PLANKA is faster at one thing we measured: adding a comment.
Our AI chat comparison leaves one objection open: server-rendered HTML may work for forms and chats, but an app with drag and drop, where several people edit the same screen at once, needs a single-page app. A Kanban board is that app. PLANKA is a real product built the single-page way, with about 12,600 stars on GitHub.
Both apps do what we compared: log in; add, rename, reorder and archive lists; add, rename, move and archive cards, by dragging and with the keyboard; a card view with a Markdown description, labels, a due date and comments; and live collaboration, where everyone on a board sees every change and who else is there.
PLANKA does a lot more: card members, search and filters, other board views, an activity history, editing comments, deleting cards, a stopwatch, attachments, task lists, custom fields, notifications, webhooks, a REST API and two-factor login. We compared only what both apps do, and PLANKA's bundle and memory also pay for the rest.
Every action on our board is a POST request that changes the database and answers with an empty 204. Each open page holds one stream of server-sent events, and after every change the server sends the board down that stream as HTML. Cards that didn't change come from a cache keyed by their content, and a slow connection gets the newest frame instead of a queue of old ones. A frame carries only the lists that changed, and Brotli compresses across frames, so a frame after one moved card costs under a kilobyte on the wire. Brotli's window belongs to one connection, so every stream compresses each frame for itself; everything else about a frame is done once, and at most half the processor cores compress at a time, so a burst of frames never holds up an action.
All writes go through the one goroutine with the write connection. While a transaction commits, new commands queue up, and the next transaction takes all of them, each in its own savepoint, so one refused command undoes only its own changes. The check "did someone move this card since your page was drawn" runs inside that command, with no lock held across the network. The design follows Anders Murphy's measurements of SQLite under contention. SQLite runs with synchronous=FULL, so every commit waits for the disk.
A dropped card stays where the server last put it and looks pending (dimmed, with a spinner) until the frame that shows it in its new place arrives; that frame also clears the pending look. Meanwhile the board opens a gap where the card was dropped and shows a dashed copy of it there: what the person did, not what the server has done. If the server refuses the move, the card stays put and the page says why: "Anna moved ‘Fix login’ to ‘Done’ meanwhile." Every action carries an id, so a request the browser sends twice after a network error is applied once.
PLANKA
What the slowed phone shows during a cold load of the 200-card board: the last frame Chrome painted by each moment. The frames come from a separate run with tracing on, which slows the page a little; the timings below come from runs without it.
Cold load of the 200-card boardOursPLANKADifference Transferred58 kB2,576 kB44× lessJavaScript transferred40 kB2,226 kB56× lessBoard on screen (largest contentful paint)0.6 s15.4 s27× soonerAll scripts in (load event)0.6 s12.5 s20× soonerLayout shift (CLS)00.02none
PLANKA downloads its whole application before it asks for the board, so on a slow connection most of the 15.4 seconds go to 2.2 MB of JavaScript. Our server sends the board as HTML in the first response, and the browser paints it as soon as the stylesheet has arrived. Our JavaScript loads after that, five files in one wave: Datastar and one file for each Starbase component. Dragging works once they are in, after 0.6 seconds on this connection.
Two seconds after the link was tapped, on the slowed phone. Drag the slider to compare.
Lighthouse
MetricOurs, desktopPLANKA, desktopOurs, mobilePLANKA, mobile Performance score100699833First contentful paint0.3 s2.4 s1.4 s14.0 sLargest contentful paint0.3 s2.6 s1.4 s14.9 sTotal blocking time0 ms140 ms160 ms990 ms
Lighthouse simulates the slow network and the slow phone itself (mobile: 150 ms round trip, 1.6 Mbit/s, 4× CPU) and keeps its own model of how requests overlap, so its mobile numbers differ from our measured ones. With one file per component, it counts 160 ms of total blocking time on mobile for our board; with the same components as 17 separate modules, it counted 80 ms.
The two apps mean different things by "shown". Both mark the target at once: PLANKA's list opens a gap during the drag and its card floats into it after the drop, and our board opens a gap with a dashed copy of the card. PLANKA moves the card itself in the browser and tells the server afterwards; its card is in the list after 481 ms, at the end of its drop animation, and the server's confirmation arrives at 712 ms. If the server refuses the move, the card has already been shown where it isn't. Our board moves the card only when the server's frame brings it, at 252 ms, and the same frame clears its pending look. PLANKA sends the move only after its drop animation, which is also why the second person sees it later.
150 ms after the drop, on the slowed phone. Ours: a gap with a dashed copy where the card goes, the card itself still dimmed in its old list. PLANKA: the card still floating into its gap.
Adding a comment
Add a comment (p50)OursPLANKADifference Comment shown302 ms90 msPLANKA 3.4× soonerComment confirmed by the server302 ms229 msPLANKA 1.3× sooner
PLANKA is faster here. It shows a new comment immediately, before the server has it, and gets the confirmation over its open WebSocket after 229 ms. Our board sends an HTTP request and shows the comment with the card view's next frame, which the slowed CPU has to morph, after 302 ms.
We also loaded our board with simulated people, each with a real compressed stream, moving random cards on the 200-card board on a fixed schedule. The tool measures what a person waits for: from sending a move to its outcome arriving on their own stream. Server and load tool ran on separate cores of the same machine; the figures are medians of three 30-second runs.
"Refused as stale" means two people moved the same card at the same moment and the second one was told who moved it where.
The database is not what the server spends its time on. Rendering the board takes about 2 ms per frame, once for everyone. At 800 moves a second, every frame changes all eight lists, about 140 kB of HTML, and each of the 200 streams compresses it with its own Brotli window: that is most of the five cores. The compressor's state is also most of the memory, about 2.2 MB per busy stream, which Go's garbage collector roughly doubles. Two hundred people on a quiet board need 150 MB.
Without HTTP or streams, our writer handles about 13,800 moves a second when 200 people move at once, and 240 to 340 when one person moves alone. At first it was about 10,000: the pure Go SQLite driver prepares a statement again on every call, and that cost 41% of the writer's CPU. Now the writer prepares each statement once and keeps it. Anders Murphy measured 98,163 transactions a second with the same design. Two things explain the difference:
A board doesn't come near the ceiling: 200 people each moving a card every 250 ms send 800 moves a second.
An empty PostgreSQL database already takes 7.3 MB, and PLANKA's data directory as a whole takes 65 MB, most of it write-ahead log segments and template databases. Our server's memory grows with the open streams, as described above.
Our first build of the board took about 120 ms of main-thread time per frame on the slowed CPU, and every key pressed during a frame waited for it, which put INP at 248 ms. Three changes brought a frame to about 55 ms:
With Datastar 1.0.4's default retry setting, a stream that the server closes cleanly, as it does during a deploy, is not reopened, and the page stops updating without any sign. Our board opens its stream with retry: 'always', a watchdog replaces a connection that went quiet, and a banner says when the page may be out of date.
If your team needs a self-hosted Kanban board with attachments, task lists, custom fields and notifications today, PLANKA has them and we haven't built them. This study is about how to build interactive software. A board with drag and drop, live collaboration and conflicts between people fits in server-rendered HTML with honest pending states, and on a slow phone it loads in well under a second and stays responsive. It runs as one binary with one file of data. If you are about to build an interactive application and assume it needs a single-page app, measure the server-driven version first.
The board runs at kanban.zweiundeins.gmbh. Log in as anna@example.com, ben@example.com, chiara@example.com or dev@example.com with the password demo, best in two browsers at once; the boards go back to their seed every night.
The source, the benchmark scripts, the PLANKA setup and all raw data are on GitHub. go tool task dev starts the board with demo data; benchmarks/RESULTS.md describes how to run every measurement in this article.
PLANKA is a trademark of PLANKA Software GmbH. We measured it independently; this article is not reviewed or endorsed by them.
Michael BolliBehind zwei und eins gmbh is Michael Bolli. For over 20 years he has built and looked after web applications, with a focus on architecture, performance and systems that stay maintainable.
正文由 探How 从来源站点 RSS 同步,内容未经改写;遇到排版缺失或需要图片、视频时请以原文为准。