Memos Worker is the small one.

After looking at FlareMo and Inkstone, I wanted to check Memos Worker because it takes a much simpler path.

No React build. No Better Auth. No Durable Objects. No Workers AI. No Vectorize. No Docker stack.

Just a Cloudflare Worker, static HTML, D1, KV, R2, and a practical notes UI.

That makes it interesting if you want a tiny Memos-inspired capture app on Cloudflare rather than a full team knowledge-base platform.

What is Memos Worker?

Memos Worker is a Cloudflare-powered notes and knowledge-base app.

The upstream README describes it as:

Memos Worker is a powerful and high-performance serverless application for notes and knowledge management.

The important wording is “Memos Worker”, not “Memos”.

This is not the official Memos Docker app. It is a separate Cloudflare-native project inspired by the Memos timeline-style note workflow.

The feature set includes:

  • Markdown notes with preview;
  • rich-text-to-Markdown paste through Turndown;
  • tags extracted from hashtags;
  • D1 full-text search;
  • list, waterfall, and date-grouped views;
  • favorites, archive, and pinning;
  • timeline, calendar, stats, and heatmap widgets;
  • R2-backed attachments and image uploads;
  • optional Imgur image uploads;
  • public note and file sharing;
  • raw Markdown public share URLs;
  • tree-structured docs/knowledge-base mode;
  • Telegram Bot capture for text, photos, videos, and files;
  • theme, background, and layout customization.

Architecture Overview

The whole app is compact:

Static HTML UI -> Worker API -> D1 notes database
                         |
                         +-> KV sessions, settings, share IDs
                         +-> R2 attachments and uploaded images
                         +-> Optional Telegram Bot API
                         +-> Optional Imgur API
Layer Memos Worker Uses
Runtime Cloudflare Workers
Static frontend Workers Static Assets
API Plain Worker fetch() router
Database Cloudflare D1
Search D1 FTS5
Session/settings/share state Workers KV
File storage Cloudflare R2
Optional capture Telegram Bot webhook
Optional image host Imgur API
Frontend libraries marked, turndown, highlight.js from CDNs

The codebase is mostly:

src/index.js          Worker API and routing
src/schema.sql        D1 schema and FTS triggers
src/public/index.html Main notes UI
src/public/docs.html  Docs/knowledge-base UI
src/public/share.html Public share UI
wrangler.toml         Cloudflare bindings

There is no bundling step. That is a real simplification compared with most modern web apps.

Cloudflare Resources

Memos Worker needs three Cloudflare data services:

Binding Service Purpose
DB D1 Notes, tags, docs nodes, FTS search tables
NOTES_KV Workers KV Login sessions, settings, public share mappings
NOTES_R2_BUCKET R2 Attachments, pasted/uploaded images, Telegram media when stored permanently

It does not use Durable Objects, Workers AI, Vectorize, Queues, or a separate SQL server.

That makes the mental model easier than something like FlareMo:

Memos Worker = small Cloudflare notes app
FlareMo = heavier Memos-style Cloudflare workspace
Inkstone = more advanced Markdown notebook

Deployment

The upstream README expects you to fork or use the repository as a template, create Cloudflare resources manually, then deploy the Worker.

The resource names suggested upstream are:

Resource Suggested Name Binding
D1 database notes-db DB
KV namespace notes-kv NOTES_KV
R2 bucket notes-r2-bucket NOTES_R2_BUCKET

You also need Worker environment variables:

Variable Purpose
USERNAME Login username
PASSWORD Login password
TELEGRAM_BOT_TOKEN Optional Telegram bot token
TELEGRAM_WEBHOOK_SECRET Optional Telegram webhook secret
AUTHORIZED_TELEGRAM_IDS Optional authorized Telegram sender ID

The D1 schema is not hidden behind a migration framework. You execute src/schema.sql against the database.

For local development:

npx wrangler d1 execute notes-db --local --file=./src/schema.sql
npx wrangler dev

For deployment:

npx wrangler deploy

Field Note: Local Smoke Test

I tested commit 25b7e9bcefe945c4d51be60b74722aa6871607ec.

The host Node.js version was 18, and Wrangler 4 refused to run:

Wrangler requires at least Node.js v20.0.0.

Using Node 24 worked:

npm ci
npx -y -p node@24 -p npm@latest bash -lc 'npx wrangler d1 execute notes-db --local --file=./src/schema.sql'
npx -y -p node@24 -p npm@latest bash -lc 'npx wrangler dev --ip 127.0.0.1 --port 8791'

One extra gotcha: Wrangler validates wrangler.toml placeholders even for local commands. The default placeholder bucket name YOUR_R2_BUCKET_NAME failed validation, so I patched the temporary clone with syntactically valid dummy IDs and names.

After that, local smoke tests passed:

curl http://127.0.0.1:8791/

curl -c /tmp/memos-worker-cookies.txt \
  -H 'Content-Type: application/json' \
  -d '{"username":"dev_user","password":"dev_password"}' \
  http://127.0.0.1:8791/api/login

curl -b /tmp/memos-worker-cookies.txt \
  -F 'content=# hello from local smoke test

#cloudflare #memos-worker' \
  http://127.0.0.1:8791/api/notes

curl -b /tmp/memos-worker-cookies.txt \
  'http://127.0.0.1:8791/api/search?q=cloudflare'

The UI returned HTML, login succeeded, note creation returned 201 Created, FTS search found the note, tags/stats worked, and public share/raw Markdown URLs were generated.

npm ci also reported 6 high-severity vulnerabilities in the installed dependency tree. Since this project only uses Wrangler as a dev dependency, that is not the same as a vulnerable production Node server, but it is still worth checking during maintenance.

Authentication Model

Memos Worker uses a single username and password configured as Worker secrets.

On successful login, it creates a UUID session in KV and sends a __session cookie:

HttpOnly; Secure; SameSite=Strict; Max-Age=2592000

That is simple and useful for a personal tool.

But it is not a full account system:

  • no multi-user roles;
  • no Better Auth;
  • no OAuth;
  • no password reset flow;
  • no observed built-in login rate limit;
  • no admin/user separation.

For an internet-exposed deployment, use a strong password and consider putting Cloudflare Access or WAF rules in front of it.

Telegram Capture

The Telegram integration is useful if you treat Telegram as a quick capture inbox.

The Worker webhook can receive:

  • plain text;
  • captions;
  • forwarded-message context;
  • replies converted to Markdown quotes;
  • photos;
  • documents;
  • videos.

Media can be handled in two ways:

Mode What Happens
Proxy on Worker creates Telegram proxy links, saving R2 space
Proxy off Worker downloads media from Telegram and stores it in R2

Proxy mode is cheaper on R2, but less permanent. If the source file disappears from Telegram, the link can break.

One source-code detail: AUTHORIZED_TELEGRAM_IDS behaves like a single sender ID in the analyzed version, because the code compares it directly to senderId.toString(). Do not assume comma-separated multi-user Telegram authorization unless upstream changes that logic.

FAQ

Conclusion

Memos Worker is a good example of the lightweight end of the Cloudflare app spectrum.

It is not as capable as FlareMo, not as notebook-focused as Inkstone, and not as local-homelab friendly as official Memos. But if you want a small personal notes app that lives entirely on Workers, D1, KV, and R2, the architecture is easy to understand and the local Wrangler smoke test worked.