cd /news/developer-tools/i-built-a-forum-with-no-framework-on… Β· home β€Ί topics β€Ί developer-tools β€Ί article
[ARTICLE Β· art-174050] src=dev.to β†— pub= topic=developer-tools verified=true sentiment=↑ positive

I built a forum with no framework on Cloudflare Workers

A developer built a framework-free forum for the Polytoria game community, running as a single Cloudflare Worker with a D1 SQLite database and plain ES-module JavaScript in the browser, covering boards, threads, polls, chat, DMs, profiles, two-factor sign-in and 41 interface languages. The design routes all visibility decisions through one module and backs it with a test that seeds hidden posts, banned authors, blocked pairs and deleted records, then sweeps every route, the MCP agent tool server and page heads to confirm none of that text leaks. That sweep caught a real bug in the last release, where a thread page's structured data counted replies from a blocked user while the feed did not.

recommendation

Centralize visibility checks in one module and run a seeded sweep across every route, agent tool endpoint and page head to catch leaks like blocked-user replies appearing in structured data.

more in playbook: Securing agents and AI tools
by read6 min views7 publishedNov 22, 2026

I run a small forum for the Polytoria game

community: wempos-forum.com. It has boards,

threads, polls, a chat lobby, DMs, profiles, two-factor sign-in and 41

interface languages. The whole thing is one Cloudflare Worker, one D1

database, and plain JavaScript modules in the browser. No React, no

bundler, no build step for the front end.

This post is about the decisions that made that work, the parts that bit

me, and some code you can steal. The project is free software

(AGPL-3.0-or-later), so all of it is in

the repo.

browser ──► Worker (worker.mjs)
              β”œβ”€β”€ /api/*        JSON routes, one handler module per area
              β”œβ”€β”€ /mcp          a tool server for AI agents
              β”œβ”€β”€ discovery     /openapi.json, sitemap, markdown versions
              └── everything else β†’ static files in public/, with a
                  per-page <head> injected on the way out
            D1 (SQLite)  ◄── every route, through bound statements

The router is a list of handlers. Each one answers the paths it owns and

returns null for everything else, so the next handler gets a turn:

const API_HANDLERS = [handleAuthRoutes, handlePostRoutes, handleProfileRoutes,
  /* …30 more… */ handleBrandingRoutes, handleAnalyticsRoutes];

Adding a feature means adding one module and one entry. There's no

framework to learn, and every route is a plain function you can call

from a test.

The browser loads public/js/*.js exactly as written, as ES modules.

That sounded like a constraint at first. In practice it means:

public/js/router.js the browser uses, so a URL the client can't route gets a real 404 from the server too. One list of page routes, no drift.eval, script-src 'self'. There's nothing to whitelist because there's nothing generated. The cost is that I write a bit more DOM code by hand. The rule that keeps

it safe: user text goes in with textContent, never innerHTML, and a

test fails the build if a new HTML sink shows up.

Forums leak in boring ways. A post gets hidden by a moderator, but it

still shows in search. A member blocks someone, but that person's replies

still appear in a notification. A banned account's posts vanish from the

feed but not from the sitemap.

So there's exactly one module that decides "can this viewer see this

post?", covering hidden posts, active bans and block pairs in both

directions. Every route that returns post text or member names goes

through it. Then there's a test that seeds one of each forbidden thing

(a hidden post, a banned author, a blocked pair, a deleted post, a

staff-only record) and sweeps every route, the agent tool server and

the page heads, asserting none of that text ever comes back.

That sweep has paid for itself. In the last release it caught a subtle

one: the structured data on a thread page counted replies from someone the

viewer had blocked, while the feed (correctly) didn't. Same SQL, one

missing filter. Without the sweep, nobody would have noticed for months.

When someone pastes a thread link into Discord, it should show the

thread's title and first lines. When the thread is hidden, it must show

nothing about it, and it must not even reveal whether the thread

exists.

The Worker rewrites the HTML shell's <head> per request. The important

part is the order: the visibility check runs first, as an ordinary

member, even for staff, so a moderator's session can't leak a hidden post

into a cached preview:

const row = await env.FORUM_DB.prepare(POST_ROW_SQL).bind(id).first();
if (!row || !(await canViewPost(env, row, viewer))) return null; // β†’ generic head

Hidden, banned, blocked, deleted and missing all fall back to the same

generic head with noindex, and a test asserts the bytes are identical.

The structured data for search engines goes in a

<script type="application/ld+json"> block. That's a trap, because a

post body containing </script> would close the tag early. The fix is to

escape after serializing:

export function jsonLdBlock(data) {
  const text = JSON.stringify(data)
    .replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026")
    .replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
  return `<script type="application/ld+json">${text}</script>`;
}

It's still valid JSON (\u003c is just < to a JSON parser), but an

HTML parser never sees a <. There's a test that posts

</script><script>alert(1)</script> and checks every block still parses

and nothing gets injected.

I wanted to know which pages people use, without tracking people. The

answer was to store counts, not visits:

CREATE TABLE page_view_counts (
  day TEXT NOT NULL, route TEXT NOT NULL, views INTEGER NOT NULL DEFAULT 0,
  PRIMARY KEY (day, route)
);

route is the router's page name: home, post, profile. It's

never the path, so no post id, username or search query ever lands in a

row. There's no IP, user agent, cookie or per-visit row. The decision to

count is one small function:

export function pageViewPlan(request, env, url, response) {
  if (!analyticsEnabled(env) || !env.FORUM_DB) return null;
  if (request.method.toUpperCase() !== "GET" || isPrefetch(request)) return null;
  if (optedOut(request) || looksLikeBot(request)) return null; // DNT / Sec-GPC
  if (!response || response.status !== 200) return null;
  if (!(response.headers.get("Content-Type") || "").includes("text/html")) return null;
  const route = routeForPath(url.pathname, url.search).name;
  if (!route || route === "not-found") return null;
  return { day: utcDay(), route, referrer: referrerHost(request, url, env) };
}

A few details I'm happy with:

reddit.com, never the full URL), and only when it's someone else's site. The number of distinct hosts per day is capped, so a flood of junk referrers can't bloat the table.ctx.waitUntil after the response is built, and any error becomes a log line, not a broken page. The staff view is a plain table of daily totals, top page types and top

referring sites. That's enough to see whether a Reddit post worked, and

it holds nothing worth stealing.

D1 is SQLite, and mostly it's lovely. A few things cost me real time:

DROP, or worse, silently cascade-delete rows in tables that reference it. For schema changes I now add a new column, backfill it, and switch reads over, instead of rebuilding tables.prepare(...).bind(...), every LIMIT is a bound number, and list sizes stay under D1's bound-parameter cap. Every deploy stamps the commit hash into the HTML and into

/api/version:

wrangler deploy --keep-vars --var COMMIT_SHA:$(git rev-parse --short HEAD)

The browser compares its own build against /api/version and shows a

"new version available" banner when they differ, and the stamp doubles as

a cache-buster for scripts. It also caught a nasty problem: a git push can

trigger a hosted build that deploys without the stamp. So the rule is

that the stamped deploy always runs last, from a checkout at the pushed

commit, and I probe /api/version until it reports that commit.

The suite (about 1,200 tests) runs with Node's built-in test runner. Routes

run against an in-memory SQLite that behaves like D1, and front-end

modules run against a small fake DOM. No headless browser, so the whole

suite takes seconds and runs on every push. Fuzz tests (fast-check)

throw thousands of malformed inputs at sign-in, search and posting.

New features land red-first: the test commit goes in failing, then the

code that makes it pass. When a change touches visibility, I break the

fix on purpose to confirm the test notices. If removing the check doesn't

fail a test, the test is wrong.

The forum is at wempos-forum.com. If you play

Polytoria or build games, come say hi. The code, self-hosting guide and

security docs are on

GitHub. I'd love

feedback on any of the above.

── more in #developer-tools 4 stories Β· sorted by recency
── more on @cloudflare workers 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain β€” perfect for shipping the agent you just read about.

$git push zahid main
β†’ Live at https://your-agent.zahid.host βœ“
Get free account β†’ Pricing
from €0/mo Β· no card required
LIVE [news/i-built-a-forum-with…] indexed:0 read:6min 2026-11-22 Β· β€”