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
Can Memos Worker run in a homelab with Docker?
Not as shipped.
Memos Worker is a Cloudflare Workers app. It can run locally through Wrangler for development, but the production target is Cloudflare Workers plus D1, KV, and R2.
If you want a local Docker notes app, use the official Memos Docker setup or another local notes tool.
Can it run solely on Cloudflare infrastructure?
Yes for the core app.
The core stack is:
Workers + Workers Static Assets + D1 + KV + R2
The optional extras are external:
- Telegram Bot API for mobile capture;
- Imgur API if you choose Imgur image uploads;
- CDN-hosted frontend libraries, unless you vendor those JavaScript files into the project yourself.
For maximum independence, I would consider vendoring marked, turndown, and highlight.js instead of loading them from public CDNs.
Is Memos Worker a PWA or offline-capable app?
No, not in the source I analyzed.
I did not find a service worker, web app manifest, IndexedDB write queue, or offline sync layer. The UI uses localStorage for preferences such as theme, layout, and sidebar state.
That makes it simpler than Inkstone or FlareMo, but it also means normal note operations require the Worker API.
How does Memos Worker compare with official Memos Docker?
Official Memos is the better fit when you want a traditional self-hosted notes server with Docker and local storage.
Memos Worker is better when you specifically want a lightweight Cloudflare-native notes app and you are comfortable storing data in D1, KV, and R2.
They share the same broad “quick notes in a timeline” idea, but they are very different operationally:
| Difference | Official Memos Docker | Memos Worker |
| — | — |
| Runtime | Container on your server/VPS/NAS | Cloudflare Worker |
| Data location | Your local volume/database | Cloudflare D1, KV, and R2 |
| Deployment style | docker run or Compose | wrangler deploy or Cloudflare Git deploy |
| Homelab fit | Strong | Mostly as a deploy target, not a local service |
| Cloudflare dependency | Optional, only if you put it behind a tunnel/proxy | Required |
| Best reason to choose it | You want local ownership and normal self-hosting | You want near-zero server maintenance on Cloudflare |
So if the goal is “I want a Docker service on my own machine”, use official Memos. If the goal is “I want a small notes app that runs on Cloudflare’s serverless stack”, Memos Worker is the closer match.
How is it different from the other Cloudflare note apps?
Memos Worker is the lightweight option among the Cloudflare-based note-taking projects covered here.
| Project | Best Fit | Stack Shape | What It Has That Memos Worker Does Not |
|---|---|---|---|
| Memos Worker | Small personal notes, docs, sharing, Telegram capture | Worker + static HTML + D1 + KV + R2 | The simplest stack; fewer moving parts |
| FlareMo | Heavier Memos-style knowledge workspace | Worker/static assets + D1 + R2 + Vectorize + Workers AI | Better Auth, team roles, PWA offline behavior, MCP, Memos-compatible APIs, projects, tasks, plugins, agent memory |
| Inkstone | Browser Markdown notebook | React/Vite app + Worker + D1 + R2/KV + Durable Objects + optional Workers AI | CodeMirror editor, richer Markdown notebook model, offline write queue, versioning, backlinks, MCP, WebDAV/S3 backups |
The decision is mostly about how much application you want.
Memos Worker = simple Cloudflare notes
FlareMo = Cloudflare Memos-style workspace
Inkstone = Cloudflare Markdown notebook
Memos Worker is the least cluttered of the three. That is good for a personal capture tool, but it also means you give up the richer auth, offline, AI, team, and notebook features from the heavier projects.
Does Memos Worker use Better Auth?
No.
It uses a single Worker-configured username and password. Sessions are stored in KV and tracked through an HttpOnly secure cookie.
That is much simpler than Better Auth, but it also means you do not get Better Auth’s multi-provider auth patterns, roles, account linking, or richer session/account model.
What Cloudflare permissions and keys are needed?
For deployment you need access to create or bind:
- one Worker;
- one D1 database;
- one Workers KV namespace;
- one R2 bucket;
- Worker environment variables/secrets;
- optionally a custom domain or route.
For CLI deployment, expect CLOUDFLARE_ACCOUNT_ID and a CLOUDFLARE_API_TOKEN with Workers, D1, KV, and R2 permissions.
Inside the app, configure at least:
USERNAME
PASSWORD
Telegram capture needs:
TELEGRAM_BOT_TOKEN
TELEGRAM_WEBHOOK_SECRET
AUTHORIZED_TELEGRAM_IDS
Imgur uploads need an Imgur Client ID stored from the app settings screen.
Is Memos Worker fully open source?
The source is public on GitHub, but I did not find a license file in the analyzed clone.
That matters. Without an explicit license, you should treat it as source-available rather than fully FOSS for redistribution or commercial reuse purposes, unless upstream adds or clarifies a license.
Can it be deployed statically to Cloudflare Pages?
Not with full functionality.
The UI files are static, but the app depends on Worker API routes and Cloudflare bindings. Notes, login sessions, settings, file uploads, search, sharing, and docs all require the Worker plus D1/KV/R2.
This is a serverless app, not a static-only site.
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.
Comments