LogChimp

LogChimp is an open-source, open-core platform for product teams that need to collect and act on customer feedback without surrendering data to a third-party SaaS. Teams create public or private boards where users submit feature requests, upvote ideas, and leave comments, while product managers consolidate the signal into visual roadmaps that communicate development priorities back to the community.

Built as a TypeScript monorepo, LogChimp separates a Node.js/Express API backend from a Vue 3 frontend theme, making it straightforward to deploy each independently or together via Docker Compose. PostgreSQL handles persistent storage, a Valkey (Redis-compatible) key-value store provides in-memory caching for hot API paths, and nodemailer powers transactional email for account verification and password resets.

Starting with v0.8.0, LogChimp adopted an open-core model. The AGPLv3-licensed community edition handles core feedback collection, boards, roadmaps, and role-based access control. A proprietary Enterprise Edition layer, loaded dynamically at runtime via a license guard wrapper, unlocks additional capabilities — domain blacklisting, advanced roadmap management, and expanded role customization — for teams that subscribe to a LogChimp Enterprise plan.

With over 1,100 GitHub stars, 13 releases spanning five-plus years, and an active release cadence that reached v0.9.0 in April 2026, LogChimp is a mature choice for startups, SaaS teams, and enterprises that want full control of their feedback pipeline without the recurring cost or data-sharing tradeoffs of hosted alternatives like Canny or UserJot.

What You Get

• Feedback Boards - Create public or private boards where users submit feature requests and vote on existing ones; posts auto-truncate titles beyond the character limit and surface the submitter’s vote status in API responses.
• Visual Product Roadmaps - Organize approved posts into multi-column roadmaps with drag-and-drop ordering; boards and roadmaps can be assigned or unassigned from individual posts at any time.
• Role-Based Access Control - Define granular permissions across six built-in roles (owner, admin, moderator, manager, contributor, viewer) with cursor-paginated role and user management APIs.
• Custom Branding - Replace the default logo via URL upload, apply custom domain settings, and configure site colors so the feedback portal matches your product’s visual identity.
• Transactional Email - Nodemailer-powered email handles account verification and password reset flows, with custom branding applied to outgoing messages and configurable SMTP settings.
• Valkey Caching Layer - In-memory key-value caching (compatible with Redis) accelerates hot read paths; the setup endpoint is cached by default and more endpoints are being covered progressively.
• Open-Core Enterprise Features - A runtime-loaded license guard unlocks domain blacklisting, advanced roadmap controls, and expanded role management for Enterprise Edition subscribers.
• Docker Compose Deployment - A production-ready compose file bundles the API, Vue theme, PostgreSQL, Valkey cache, and a one-time database migrator service, enabling zero-config self-hosting.

Common Use Cases

• SaaS product feedback loop - A startup embeds a link to their LogChimp board in the app’s help menu, letting users submit and upvote feature requests that the product team reviews each sprint to inform the next release cycle.
• Enterprise client prioritization - A B2B company self-hosts LogChimp on an internal domain, assigns customer success managers as moderators, and uses the upvote count on posts to negotiate feature timelines with enterprise accounts.
• Open-source project governance - A maintainer uses a public LogChimp board so the community can propose and vote on enhancements, then publishes a roadmap view to signal what is planned, in progress, and shipped.
• Replacing expensive SaaS feedback tools - A product manager migrates off Canny to eliminate per-seat costs, retains full ownership of historical feedback data in a PostgreSQL database, and customizes the portal to match internal branding.
• Multi-product portfolio tracking - A team running several products deploys a single LogChimp instance with separate boards per product, using RBAC to grant each product manager access only to their relevant boards and posts.

Under The Hood

Architecture LogChimp is a cleanly separated monorepo where an Express-based API server, a Vue 3 frontend theme, a shared TypeScript types package, and a Playwright end-to-end test suite each live as independent pnpm workspace packages. The API follows a layered pattern — route handlers delegate to controller functions, which call service modules for business logic, with Knex managing database access and Valibot enforcing runtime request body validation at the HTTP boundary. The open-core enterprise layer is loaded lazily at startup via a dynamic import in the license guard wrapper; if the EE module is absent, the wrapper falls back to a community edition guard that blocks premium-tier routes with a structured 403 response. This design keeps proprietary code entirely separate from the AGPLv3 core without requiring compile-time flags.

Tech Stack The backend runs on Node.js 22 with Express 4, TypeScript, and Knex for PostgreSQL query building, while Valibot handles schema validation on incoming requests. A Valkey (Redis-compatible) in-memory store, accessed via the iovalkey client, caches frequently read endpoints and is designed to be incrementally applied as coverage expands. The Vue 3 frontend uses Pinia for state management, VueRouter for client-side navigation, Reka UI for accessible component primitives, and Tailwind CSS v4 for styling. The build chain runs Vite for the theme and ts-node for the API, with Biome handling formatting and linting across the entire repo. CI uses GitHub Actions for test runs, Lefthook for pre-commit hooks, Renovate for dependency updates, and Lighthouse for frontend performance auditing.

Code Quality The test suite spans three layers: Vitest unit tests for helpers and service logic, Supertest-based integration tests for API endpoints with seed data and transaction rollback isolation, and Playwright end-to-end specs covering boards, posts, votes, roadmaps, comments, and roles. Error responses follow a consistent structured format with explicit message strings and machine-readable code identifiers, making client-side error handling predictable. TypeScript strict mode is enforced across both packages, with a shared types workspace package keeping API contracts and frontend expectations in sync. Biome replaces ESLint and Prettier as a single formatting and linting tool, and Lefthook runs checks on every commit.

What Makes It Unique LogChimp’s license guard wrapper is an architecturally distinctive approach to open-core feature gating: rather than compile-time feature flags or a separate binary, EE functionality is dynamically imported at runtime and gracefully degraded when the licensed module is absent. Domain blacklisting and mail configuration validation are implemented as first-class Express middleware, enforced before any user-facing flow begins, which reflects a security-first design philosophy unusual among community feedback tools. The separation of database migration into a dedicated Docker service (rather than running migrations inside the main application process) reduces upgrade risk in production and aligns with the principle of single-responsibility containers.

Self-Hosting

LogChimp uses a dual-license model. The community edition — everything outside the packages/server/src/ee and packages/theme/src/ee directories — is released under the GNU Affero General Public License v3 (AGPLv3). AGPLv3 is a strong copyleft license: you can use, modify, and distribute the software freely, including commercially, but if you run a modified version as a network service you must release your modifications under the same license. For most self-hosting teams that run LogChimp internally without redistributing it, this is a non-issue. The enterprise edition code residing in the EE directories is governed by a separate proprietary LogChimp EE License that requires a paid subscription from Shinkly Private Limited and prohibits modification, redistribution, or use in production without a valid agreement.

Running LogChimp yourself means operating a multi-service stack: the API server, the Vue 3 frontend theme, PostgreSQL 12+, and a Valkey (Redis-compatible) cache instance. The project ships a production Docker Compose file that wires all four services together with health checks and a one-time database migrator, so initial deployment is manageable on a single Linux VM. Ongoing operational responsibility includes routine PostgreSQL backups, Valkey persistence configuration, SSL termination via a reverse proxy, and monitoring the API for error spikes. Database schema migrations are shipped with each release and are applied by running the migrator container before starting the API, which keeps upgrades deterministic but requires a deliberate maintenance window.

LogChimp also offers a hosted SaaS option at logchimp.app with an Enterprise tier that adds features unavailable in the community edition, such as domain-based user blacklisting, advanced roadmap management, and expanded RBAC. Self-hosters on the community edition do not have access to these EE features unless they purchase an Enterprise license. Managed hosting shifts the operational burden of backups, updates, SSL, and uptime to the LogChimp team, and includes access to official support channels and any SLA commitments tied to the subscription tier. Teams that need guaranteed uptime or lack in-house infrastructure expertise should weigh the subscription cost against the time saved on operations.