# Apache Answer: self-hosted Q&A software for teams, installed with one Docker command

> Apache Answer is a Go and React Q&A platform packaged as a single container image. The README gives a one-line Docker start, and the repository shows the build, plugin and configuration layout behind it.

**apache/answer** — A Q&A platform software for teams at any scales. Whether it's a community forum, help center, or knowledge management platform, you can always count on Apache Answer.

- Repository: https://github.com/apache/answer
- Website: https://answer.apache.org
- Stars: 15,682 · Forks: 1,368
- Language: Go
- License: Apache-2.0
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/apache-answer

## What Apache Answer solves, and which teams it is for

Apache Answer is Q&A platform software you host yourself. The README describes it as suitable for teams at any scale and names three uses: a community forum, a help center, or a knowledge management platform. Those are different shapes of the same object. A forum accumulates threads from outsiders; a help center answers the same recurring questions for customers; a knowledge base is internal and read more than it is written. Answer does not ship three products for those cases. It ships one Q&A structure and leaves the framing to you.

The people who benefit are the ones who already accept running a service. The repository is a Go backend with a React and TypeScript frontend, distributed as the apache/answer container image and as source. There is no hosted offering described in the README. If your team has no one who can run a container, attach a volume, and later read a changelog before upgrading, the project's own quick start is the point where that gap shows up.

The project sits under the Apache Software Foundation, which matters for procurement more than for features. The LICENSE file at the repository root is Apache-2.0, and the NOTICE file is present, which is the paperwork a foundation release carries.

## How Answer is put together: Go server, React UI, plugin layer

The repository layout tells most of the story. cmd/ holds the entry point, internal/ the server code, pkg/ shared packages, ui/ the frontend, plugin/ the plugin interfaces, and configs/ the configuration files. The Go module is github.com/apache/answer, and go.mod requires Go 1.25.0. The HTTP layer is gin-gonic/gin, database drivers for MySQL and PostgreSQL are both present (go-sql-driver/mysql and lib/pq), and bluemonday handles HTML sanitization, which is what you would expect from software that renders user-submitted posts.

Two dependencies are worth noting because they hint at scope beyond a plain forum. github.com/mark3labs/mcp-go appears in go.mod, so the project carries an MCP integration surface. github.com/mozillazg/go-pinyin is also there, a Chinese romanization library, consistent with an internationalized product; the i18n/ directory and crowdin.yml confirm translation work is part of the repository.

The plugin system is the extension path. The README points to plugin documentation and a plugin listing on answer.apache.org, and the Dockerfile runs script/build_plugin.sh during the image build, so plugins are compiled in rather than dropped into a directory at runtime. That is a meaningful design choice: extending Answer means building, not uploading.

## Installing Apache Answer with Docker and running the first question

The README's quick start is a single docker run. It maps host port 9080 to port 80 in the container, mounts a named volume at /data, and names the container answer. The image tag in the README is pinned to 2.0.2, matching the most recent release listed for the project.

```bash
docker run -d -p 9080:80 -v answer-data:/data --name answer apache/answer:2.0.2
```

After the container starts, open http://localhost:9080. The volume at /data is where the container keeps its state, so removing the container without removing the volume leaves the data in place.

The repository also carries a docker-compose.yaml that expresses the same deployment. It uses the unpinned image apache/answer, the same port mapping, restart: on-failure, and the answer-data volume.

```yaml
services:
  answer:
    image: apache/answer
    ports:
      - '9080:80'
    restart: on-failure
    volumes:
      - answer-data:/data
```

For an unattended deployment, .env.example exposes the knobs. INSTALL_PORT defaults to 80 and AUTO_INSTALL to false. Database settings are DB_TYPE, DB_USERNAME, DB_PASSWORD, DB_HOST, DB_NAME and DB_FILE. Site settings are LANGUAGE (en-US by default), SITE_NAME, SITE_URL and CONTACT_EMAIL, and the first administrator is created from ADMIN_NAME, ADMIN_PASSWORD and ADMIN_EMAIL.

```bash
INSTALL_PORT=80
AUTO_INSTALL=false
DB_TYPE=
DB_USERNAME=
DB_PASSWORD=
DB_HOST=
DB_NAME=
DB_FILE=
```

Those keys ship empty in the example file, so the values come from your own environment, and the README does not show a worked example of filling them in. The installation page linked from the README is where that detail lives.

Building from source is a different path. The README lists prerequisites of Golang 1.23 or newer, Node.js 20 or newer, pnpm 9 or newer, mockgen 0.6.0 or newer and wire 0.5.0 or newer, and gives three make targets in order.

```bash
make generate
make ui
make build
```

The README notes that make check reports whether wire and mockgen are installed. Note the version skew between the two sources: the README asks for Go 1.23 or newer while go.mod declares go 1.25.0, and the Dockerfile builds on golang:1.25-alpine. Treat 1.25 as the version the current tree expects.

## Where Answer stops being the right tool

The README does not document an upgrade procedure. There is no migration command, no rollback path, and no statement about schema compatibility between releases. For a self-hosted database-backed service, that silence is the largest operational risk in the repository, and it is not something a reader can resolve from the README alone. The release list shows 2.0.2 preceded by two release candidates, which suggests a deliberate release process, but a process is not a documented upgrade path.

Configuration is thin in the same way. .env.example covers installation, database, site, admin, content display, Swagger and logging keys, and that is the whole visible surface. LOG_LEVEL defaults to INFO and LOG_PATH is empty. Nothing there addresses backups, retention, or what happens to the /data volume during an image change.

The plugin model is a constraint, not just a feature. Because plugins are compiled during the image build, a plugin written against one Answer version is tied to how that image was produced. If you need to add behaviour without rebuilding the container, this architecture works against you.

Finally, the README describes no hosted or managed option. A small team that wants a Q&A space and has no appetite for running a database and a container should look elsewhere rather than adopt Answer and defer the operations work.

## Answer compared with a wiki-style knowledge base

The closest alternative in practice is not another Q&A product but a general wiki or documentation platform. The difference is structural. A wiki is organized around pages that a maintainer edits toward correctness; the page is the unit, and its history is a record of revisions. Answer is organized around questions and answers, where the unit is a thread and the useful signal is which answer the asker accepted. That changes what the software has to do: Answer needs post types, voting and acceptance semantics, and a frontend built around reading a thread, which is why the repository splits into a Go server and a React UI rather than a single server-rendered content tree.

A wiki also tends to win on one axis Answer does not address in its README: editing an existing answer into a canonical document. If your content is closer to reference material that a small group curates, a wiki's page model fits better than a thread model. If your content is closer to questions arriving from users who need an answer and a place to mark it solved, Answer's structure is the one that matches.

The honest comparison is about the content's shape, not about which project is better maintained. Both are self-hosted, both put operational work on you, and the README of Answer does not claim otherwise.

## Licence, maintenance signals and the cost of staying current

Apache Answer is licensed under Apache-2.0, with the LICENSE and NOTICE files at the repository root and a licenserc.toml for header checking. For most adopters that means permissive use with the usual obligations around notices and attribution. This is a description of what the repository contains, not legal advice; if you redistribute Answer or a modified build, have your own counsel read the licence and NOTICE rather than relying on a summary.

The maintenance picture from the repository metadata is current: the project is not archived, and the last push to the main branch was on 2026-09-18, three days before this writing. The most recent release is v2.0.2 from 2026-07-21, following two release candidates in the same month. Those facts describe activity; they say nothing about how stable the database schema is between releases, which is the question an operator actually cares about.

The upgrade cost is therefore unknown from the repository alone, and that is the number to establish before you depend on Answer. The concrete things you can check are the release notes attached to each tag and the installation documentation linked from the README. The concrete thing you cannot check from here is whether a 2.0.2 to a later 2.x upgrade runs without intervention, because nothing in the repository states it. Budget for reading the changelog of every version you skip, and for testing the upgrade against a copy of the /data volume before touching production.

## Conclusion

Apache Answer fits teams that want a self-hosted Q&A space and can run a container: the README's one-line Docker start puts it on port 9080 with data in the answer-data volume, and the Makefile targets cover source builds. It is the wrong pick if you need a hosted service with no operations work, or if you expect the README to explain upgrades, since it documents neither rollback nor migration. Before committing, verify the database type you intend to use against the .env.example keys, confirm the image tag you pin, and read the installation page linked from the README for details the repository itself does not carry.

## FAQ

### How do I install Apache Answer?

The README's quick start runs the published image with docker run -d -p 9080:80 -v answer-data:/data --name answer apache/answer:2.0.2, after which the platform is reachable on port 9080. A docker-compose.yaml in the repository expresses the same deployment with the answer-data volume.

### What database types does Apache Answer support?

The .env.example file exposes DB_TYPE, DB_USERNAME, DB_PASSWORD, DB_HOST, DB_NAME and DB_FILE, all empty by default, and go.mod includes drivers for MySQL and PostgreSQL. The README does not list the accepted values for DB_TYPE.

### Can I build Apache Answer from source?

Yes. The README lists Golang 1.23 or newer, Node.js 20 or newer, pnpm 9 or newer, mockgen 0.6.0 or newer and wire 0.5.0 or newer as prerequisites, then three make targets in order: make generate, make ui and make build.

### Does Apache Answer support plugins?

The README states that Answer provides a plugin system for developers to create custom plugins, and links to plugin documentation and a plugin listing on answer.apache.org. The Dockerfile runs script/build_plugin.sh during the image build, so plugins are compiled into the image.

### How do I upgrade Apache Answer to a new version?

The README does not document an upgrade or rollback procedure, so the repository itself gives no steps. The release tags and the installation documentation linked from the README are the places to check before changing an image tag.

## Sources

- [apache/answer on GitHub](https://github.com/apache/answer)
- [License: Apache-2.0](https://github.com/apache/answer/blob/main/LICENSE)
- [Project website](https://answer.apache.org)
- [README](https://github.com/apache/answer/blob/main/README.md)
- [Releases](https://github.com/apache/answer/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/apache-answer