ClearFlask

ClearFlask is an open-source alternative to Canny and UserVoice, built for product teams that want to own their feedback data without paying per-seat SaaS fees. It provides a fully branded feedback portal where users can submit ideas, vote on requests, and track the status of features from Planned to Released — all embedded directly into your product via a JavaScript widget or hosted on a custom domain.

The platform pairs a Java-based API server with a Node.js Connect layer for server-side rendering and dynamic TLS certificate management. Data storage is modular: choose between MySQL or Elasticsearch for search, DynamoDB for primary storage, and S3 or MinIO for file uploads. This architecture makes it deployable everywhere from a single Docker Compose setup to a full Kubernetes cluster with Helm charts and horizontal autoscaling.

Beyond basic feedback collection, ClearFlask includes an AI assistant powered by LangChain4j and OpenAI that lets users query their feedback corpus conversationally and generate summaries of recurring themes. The roadmap view supports three distinct prioritization mechanisms — community voting, credit-based funding, and emoji expressions — so teams can tune how their users signal what matters most.

Integrations with GitHub, GitLab, Jira, and Slack connect feedback items directly to the engineering workflows where work actually gets done. The webhooks system, SSO support via SAML and OAuth, and role-based access controls make ClearFlask viable for B2B products serving enterprise customers who need private project spaces and audit-ready data ownership.

What You Get

• AI-Powered Feedback Assistant - Ask natural language questions about your feedback corpus using the built-in LangChain4j agent, which searches posts, summarizes themes, and surfaces patterns from across all user submissions.
• Three Prioritization Modes - Let users signal demand through community voting, credit-based funding where users allocate budgets to features, or emoji expressions — each giving product teams a different signal for prioritization.
• Embeddable Feedback Widget - Inject the feedback portal directly into your app using a JavaScript snippet, keeping users in context while capturing suggestions without redirecting to a separate domain.
• Public Roadmap with Status Tracking - Display feature statuses (Planned, In Progress, Released) on a branded public roadmap that updates automatically as ideas move through the pipeline.
• GitHub, GitLab, Jira, and Slack Integrations - Link feedback items to engineering tickets bidirectionally, receive Slack notifications on activity, and close the loop between user requests and code shipped.
• Custom Domain and Whitelabeling - Deploy the portal under your own domain with full brand customization including colors, logos, and content templates — with automated TLS via Let’s Encrypt built in.
• SSO and SAML Authentication - Authenticate users via SAML, OAuth (Google, GitHub), or the ClearFlask SSO protocol, enabling enterprise customers to use their existing identity provider.
• Flexible Deployment Stack - Swap dependencies to match your infrastructure: MySQL or Elasticsearch for search, DynamoDB or LocalStack, S3 or MinIO for storage, AWS SES or any SMTP server for email.

Common Use Cases

• SaaS product with active user communities - A startup embeds the feedback widget in their dashboard, collects feature requests with voting, and shares a public roadmap to keep users invested in the product direction.
• B2B product serving enterprise clients - A company uses private projects, SSO, and role-based access to let each enterprise customer submit and view only their own feedback, then uses AI summarization to prioritize across accounts.
• Open-source project community governance - A maintainer self-hosts ClearFlask to let users vote on issues, links approved items to GitHub issues, and publishes a roadmap that aligns contributors with user demand.
• Replacing a paid feedback tool with owned infrastructure - A privacy-conscious team migrates from Canny by exporting CSV data, self-hosting on Kubernetes with existing AWS infrastructure, and eliminating a $500/month vendor bill.
• Internal product feedback at scale - A large product org creates per-team projects, uses the credit funding model to force trade-off decisions among internal stakeholders, and tracks outcomes via the changelog.

Under The Hood

Architecture ClearFlask follows a layered monolith pattern with clear separation between API resource handlers, service-layer business logic, and pluggable storage adapters. The Java server uses Google Guice for dependency injection throughout — resources, stores, and services are all wired through Guice modules, with ClearFlaskModule as the base abstraction and ServiceInjector composing the full application graph. The OpenAPI spec in clearflask-api defines the contract between frontend and backend, and all resource classes implement generated interfaces, keeping the API surface honest. The clearflask-connect Node.js layer handles SSR, dynamic TLS certificate issuance via Let’s Encrypt, and static file serving — decoupled from the Java tier so each scales independently. Storage backends are accessed through interface abstractions (IdeaStore, UserStore, VoteStore) with concrete implementations for DynamoDB, Elasticsearch, MySQL, and S3, making it possible to swap providers without touching business logic.

Tech Stack The backend is Java 11 running on embedded Tomcat, built with Maven and structured as a multi-module project. Google Guice handles dependency injection across the service layer, with ICE Config for live property reloading via JMX or file-based sources. Storage uses AWS DynamoDB (via DataSpray SingleTable) for primary data, with a choice of Elasticsearch or MySQL for search and filtering. File uploads go to S3 or MinIO. The AI features use LangChain4j against the OpenAI API, with LlmToolingStore exposing structured tool calls the agent can invoke. The frontend is React 18 with TypeScript, Material UI, and react-i18next for internationalization, bundled with Webpack and served through a Next.js-style Node.js Connect server. Deployment is handled through Docker Compose profiles or production-ready Kubernetes Helm charts with HPA and rolling updates.

Code Quality The test suite covers 74 Java test files, including parameterized store tests that run the same suite against multiple backends (DynamoDB, MySQL, Elasticsearch) to validate behavioral consistency across storage providers. Lombok reduces boilerplate on immutable value objects, and the codebase uses Optional consistently for nullable returns rather than null leaks. Error handling is explicit — ApiException maps cleanly to HTTP status codes, rate limiters use typed annotations (@Limit), and Castle anti-spam integration wraps user-facing endpoints. The frontend enforces TypeScript strict mode and uses a generated API client from the OpenAPI spec, keeping types synchronized between tiers. CI runs on GitHub Actions with build and test gates on every pull request.

What Makes It Unique ClearFlask’s most distinctive technical choice is its multi-mode prioritization system: voting, credit funding, and emoji expressions are all first-class models configurable per-project, giving product teams a tool that fits different organizational cultures rather than imposing one feedback philosophy. The LangChain4j agent integration with custom tool specifications (searchPosts, filterByCategory, etc.) makes the AI genuinely useful — it operates over real project data through structured API calls rather than summarizing free text. The clearflask-connect layer’s dynamic TLS certificate provisioning lets each customer project have its own verified subdomain or custom domain without manual ops work, which is a meaningful self-hosting quality-of-life feature usually only found in managed SaaS. The config-driven permission and plan model allows feature access to be toggled dynamically through property files without redeployment.

Self-Hosting

ClearFlask is released under the Apache License 2.0, a permissive open-source license that allows commercial use, modification, distribution, and private deployment without any copyleft obligations. You can deploy ClearFlask internally, embed it in commercial products, and modify the source code freely. The license requires attribution in derivative works and preservation of the existing NOTICE file, but imposes no restrictions on how you run or monetize your deployment.

Running ClearFlask yourself requires meaningful infrastructure: at minimum a JVM host for clearflask-server, a Node.js host for clearflask-connect, a DynamoDB-compatible store (AWS or LocalStack), a MySQL or Elasticsearch instance for search, an S3-compatible store for file uploads, and an SMTP or AWS SES setup for transactional email. The Docker Compose quick-start bundles all dependencies in a single command, which works well for evaluation or low-traffic internal tools. Production deployments are expected to use Kubernetes via the provided Helm charts, which add horizontal autoscaling, rolling updates, and persistent volume claims for each stateful dependency. You are responsible for backups, schema migrations between releases, and monitoring — the project provides no managed update mechanism beyond new Docker image tags.

The hosted cloud offering at clearflask.com handles all infrastructure, updates, TLS, and backups automatically and provides access to the team for support. Self-hosting trades that operational convenience for full data sovereignty and the ability to customize any part of the stack. There is no feature-gating between self-hosted and cloud versions in the open-source code — the same codebase powers both. Teams evaluating self-hosting should weigh the Java + Node.js + DynamoDB + MySQL operational footprint honestly against a managed plan; the tool is production-capable but not trivially operated at scale without DevOps investment.