FeedLog - Self-Hosted Feedback, Roadmap, and Changelog Tool

FeedLog is a useful find because it sits between two worlds we have been comparing lately.

It can run as a normal Docker app on a VPS or homelab, but it can also run on Cloudflare Workers or Vercel.

That makes it a good example of a modern Nuxt application where the app code is portable, while each deployment target swaps in its own platform primitives for database connectivity, file storage, queues, and scheduled work.

What is FeedLog?

FeedLog is an open-source feedback and product communication tool.

Collect product feedback, run a public roadmap, and publish changelogs — from a tool you own and control.

It covers the loop many small software teams eventually need:

• collect feature requests;
• let users vote and comment;
• merge similar ideas;
• organize feedback into a roadmap with Kanban-style columns;
• publish changelog entries when things ship;
• expose a widget/inbox inside your own product;
• optionally use AI for duplicate detection and changelog drafting.

The project is MIT licensed ❤️.

The Important Self-Hosting Detail

Yes, FeedLog can be self-hosted on Cloudflare Workers, Vercel, or Docker.

But it is not a tiny SQLite app.

All routes need PostgreSQL 17+ with pgvector. That is the shared foundation for normal application data and vector-powered similar-idea detection.

The deployment target changes how the rest is wired:

So this is not the same as the pure Cloudflare Workers, D1, KV, and R2 stack we covered earlier.

FeedLog on Cloudflare still needs external Postgres. Cloudflare Hyperdrive makes that connection more practical from Workers, but it does not replace the database.

Tech Overview

FeedLog is built on a modern Vue/Nuxt stack:

The AI features are optional. Without OPENAI_API_KEY, FeedLog still works as a feedback, roadmap, changelog, and inbox tool. You just lose similar-idea detection, widget agent features, and AI changelog drafting.

Transactional email is also optional. Without a provider such as Resend, development email is logged instead of sent.

What the UI Gives You

After running the local Docker stack, the product shape is clear: FeedLog is not only a feedback form.

The public-facing side gives visitors:

• a feedback board with posts, voting counts, comments, statuses, and board filters;
• a roadmap view grouped into Kanban-style columns such as planned, in progress, and done;
• a changelog area for published release notes;
• a widget/inbox surface for embedding conversations inside another product.

The dashboard side is where the team manages the system:

• create and reorder boards;
• triage feedback;
• update statuses;
• merge duplicate ideas;
• manage roadmap items;
• draft and publish changelogs;
• configure widget behavior;
• review inbox conversations.

So the practical mental model is:

public portal = read, submit, vote, comment
dashboard     = organize, moderate, publish, configure

Self-Hosting FeedLog with Docker

For homelab use, Docker is the cleanest path because the compose stack can include Postgres with pgvector.

I added a Home-Lab compose here:

• Home-Lab FeedLog Docker Compose

The compose pins the app to ghcr.io/linkcraftstudio/feedlog:v0.5.0, uses pgvector/pgvector:pg17, mounts persistent volumes, and exposes the app on 3030 by default.

services:
  db:
    image: pgvector/pgvector:pg17
    container_name: feedlog-db
    restart: unless-stopped
    environment:
      POSTGRES_DB: feedlog
      POSTGRES_USER: feedlog
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
    volumes:
      - feedlog-db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U feedlog -d feedlog"]
      interval: 5s
      timeout: 5s
      retries: 12
    networks:
      - feedlog

  app:
    image: ${FEEDLOG_IMAGE:-ghcr.io/linkcraftstudio/feedlog:v0.5.0}
    container_name: feedlog
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
    environment:
      - DATABASE_URL=postgresql://feedlog:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@db:5432/feedlog
      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET:?Set BETTER_AUTH_SECRET in .env}
      - SYSTEM_ADMIN_EMAILS=${SYSTEM_ADMIN_EMAILS:?Set SYSTEM_ADMIN_EMAILS in .env}
      - AUTH_EMAIL_ENABLED=${AUTH_EMAIL_ENABLED:-true}
      - UPLOAD_PREFIX=${UPLOAD_PREFIX:-uploads}
      - BETTER_AUTH_URL
      - GOOGLE_CLIENT_ID
      - GOOGLE_CLIENT_SECRET
      - GITHUB_CLIENT_ID
      - GITHUB_CLIENT_SECRET
      - AUTH_EMAIL_VERIFY
      - OPENAI_API_KEY
      - OPENAI_BASE_URL
      - OPENAI_TEXT_MODEL
      - EMAIL_PROVIDER
      - RESEND_API_KEY
      - EMAIL_FROM
      - S3_ACCESS_KEY_ID
      - S3_SECRET_ACCESS_KEY
      - S3_BUCKET
      - S3_ENDPOINT
      - S3_REGION
    volumes:
      - feedlog-app-data:/app/.data
    ports:
      - "${FEEDLOG_PORT:-3030}:3000"
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "node -e \"fetch('http://127.0.0.1:3000/health').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))\""
        ]
      interval: 20s
      timeout: 5s
      retries: 6
      start_period: 30s
    networks:
      - feedlog

volumes:
  feedlog-db-data:
  feedlog-app-data:

networks:
  feedlog:

Create .env from the sample in Home-Lab:

cp .env.sample .env
openssl rand -hex 32

Minimum values:

POSTGRES_PASSWORD=replace-with-a-long-random-postgres-password
BETTER_AUTH_SECRET=replace-with-openssl-rand-hex-32
SYSTEM_ADMIN_EMAILS=[email protected]
AUTH_EMAIL_ENABLED=true
FEEDLOG_PORT=3030

Then start it:

docker compose up -d

Open:

http://localhost:3030

Sign up using an email listed in SYSTEM_ADMIN_EMAILS; that first matching user becomes admin.

With the sample values above, the bootstrap admin email is:

[email protected]

There is no default admin password. You choose the password yourself on the first signup screen, using that email address.

In my local run, the UI came up fully from the Docker stack. The health endpoint passed, the root page returned 200 OK, and the app exposed the feedback, roadmap, changelog, dashboard, and auth flows through the browser. Screenshots can be added later without changing the deployment notes.

Field Note: Docker Trial

I validated the Home-Lab compose with:

POSTGRES_PASSWORD=replace-me \
BETTER_AUTH_SECRET=replace-me-32-characters-long-secret \
SYSTEM_ADMIN_EMAILS=[email protected] \
docker compose config

Then I started a temporary test instance on port 3806:

POSTGRES_PASSWORD=feedlog-test-postgres \
BETTER_AUTH_SECRET=feedlog-test-secret-012345678901234567890123456789 \
SYSTEM_ADMIN_EMAILS=[email protected] \
FEEDLOG_PORT=3806 \
docker compose -p feedlogtrial up -d

The health endpoint passed:

curl -fsS http://127.0.0.1:3806/health

Returned:

{"status":"ok","timestamp":"2026-10-06T13:05:56.476Z"}

The root page also returned HTTP/1.1 200 OK.

One practical issue came up: optional auth variables should not be passed as empty strings. When I did that initially, the container failed with:

[auth] No sign-in method configured. Enable OAuth ... or set AUTH_EMAIL_ENABLED=true.

The Home-Lab compose now sets AUTH_EMAIL_ENABLED=true for the simple Docker path and leaves optional OAuth/AI/email/S3 variables as pass-through values.

Cloudflare Workers Deployment

FeedLog on Cloudflare Workers uses:

• Workers for the app runtime;
• Hyperdrive as the POSTGRES binding to external Postgres;
• R2 as the BLOB binding for uploaded files;
• Cloudflare Queues for inbox work;
• cron triggers for daily recovery;
• Worker secrets for auth, admin bootstrap, OAuth, AI, and email secrets.

Manual setup looks like:

pnpm install
wrangler hyperdrive create feedlog --connection-string="postgresql://USER:PASSWORD@HOST:5432/DATABASE"
wrangler r2 bucket create feedlog
wrangler secret put BETTER_AUTH_SECRET
wrangler secret put SYSTEM_ADMIN_EMAILS
pnpm build:cf
pnpm deploy:cf

On first request, the deployed Worker serves /setup, which runs migrations against the Hyperdrive-bound database. The vector extension must already exist in Postgres.

This is Cloudflare-native deployment, but not Cloudflare-only storage. You still need Postgres somewhere reachable from Cloudflare.

Vercel Deployment

Vercel is the managed Node path.

The repo has vercel.json with:

{
  "buildCommand": "pnpm build:vercel",
  "crons": [
    {
      "path": "/api/internal/scheduler/schedule",
      "schedule": "0 3 * * *"
    }
  ]
}

pnpm build:vercel runs migrations before the Nuxt build. That means a migration failure stops the new deploy instead of shipping a broken app.

For Vercel, the easiest database pairing is Neon or Supabase with pgvector enabled. Vercel Blob is optional but needed if you want uploads.

FAQ

Cloudflare Workers + Hyperdrive + R2 + Queues + Cron
                         |
                         v
              external Postgres with pgvector

POSTGRES_PASSWORD=...
BETTER_AUTH_SECRET=...
SYSTEM_ADMIN_EMAILS=...

AUTH_EMAIL_ENABLED=true
SYSTEM_ADMIN_EMAILS=[email protected]

GOOGLE_CLIENT_ID
GOOGLE_CLIENT_SECRET
GITHUB_CLIENT_ID
GITHUB_CLIENT_SECRET