Zammad knowledge base setup

A Zammad knowledge base lets customers find answers without opening tickets and lets agents reuse solved work. This page covers the configuration decisions, setup sequence, and what to confirm before building.

On this page

Zammad knowledge base setup for self-service and agent reuse

Zammad's knowledge base gives you a public article space for customers and a separate internal space for agents, and version 7.2 can draft knowledge base answers from solved tickets. If your support team keeps answering the same questions across email, chat, forms and phone, this section is where you decide whether those answers should live in one reusable place. Teams usually need a knowledge base when repeat questions consume a visible share of agent time, when customers ask for a way to help themselves outside business hours, or when answers differ from agent to agent because nothing authoritative exists. Zammad is licensed under the GNU Affero General Public License version 3, so you can deploy it in your own cloud accounts, data centers or air-gapped networks and keep both articles and ticket history under your control.

Treat this as a configuration project, not a toggle. The knowledge base needs a category structure that matches how customers actually search, permissions that decide which articles are public, internal or restricted, and a publishing workflow that says who can approve an article before it goes live. Each of these choices shapes the others. A category tree built around your org chart rarely helps a customer find an answer, and a public space that agents edit without review can publish outdated pricing or policy text. Before building anything, list the top recurring questions from your ticket history, group them by product or process, and assign an owner to each group. Confirm with Zammad's current admin documentation which roles can create, edit and publish articles in each space, since role names and options change between releases.

The 7.2 drafting feature changes the economics of writing articles, but it does not remove the need for review. According to the Zammad 7.2 release notes, the release can generate draft knowledge base answers from solved tickets and suggests relevant articles in the ticket sidebar through semantic search. Plan a review step for every AI-generated draft, check it against the current product behavior, and decide whether drafts are created by agents, by a lead, or by a scheduled process. Also decide how suggested articles should be handled when they are outdated, since agents will rely on those suggestions during live conversations. Test the suggestion quality on a copy of your real ticket data before rollout, and record what you find so the publishing rules reflect actual results rather than assumptions.

Plan the work around the things that most often go wrong: duplicate articles across languages, unclear ownership after staff changes, and public pages that expose internal wording. Ask your implementation partner or internal team to define the languages you will publish in, the custom URL and branding for the public space, and a schedule for reviewing articles that cover fast-changing features. Verify access separately for an anonymous visitor, a logged-in customer and an agent, and confirm that internal articles never appear in public search. Document these checks as part of the handover so that the knowledge base remains governed after the initial build.

Which knowledge base options fit which support model

This table compares five knowledge base options against the support models they suit and the upkeep each one adds. Read each row as a commitment: enable an option when your team can keep its maintenance column staffed. The main takeaway is that the 7.2 AI drafting and article suggestions depend on a well-maintained article library, so settle the structure first.

OptionWhen it fitsWhat it commits the team to maintain
Categories and permissionsFits a team serving several audiences, such as customers, partners and internal agents, who must see different articles.A category tree with a named owner per area, and a regular review of who can see each category.
Multiple languagesFits when customers write in more than one language and each translation has an accountable owner.Translations kept in step with source articles, plus a way to flag translations that no longer match.
Custom URLFits a public help center that should appear under your own domain and brand.DNS records, TLS certificate renewal, reverse proxy routing, and link checks after any domain change.
Scheduled publishingFits launches tied to product releases or policy dates, where several articles must go live together.A content calendar with an owner, and checks that scheduled articles still match current product behavior.
AI drafting from solved tickets (7.2)Fits teams with steady ticket volume and a reviewer who edits drafts before anything is published.Human review of every draft, a written rule on what may be published, and periodic checks of draft quality.
Article suggestions in the ticket sidebar (7.2)Fits agents who reuse existing answers and need relevant articles while working a ticket.Article coverage and quality, because suggestions can only point to articles that already exist. Confirm how your deployment handles suggestion data.

How categories and permissions decide what customers and agents see

Before you publish anything, decide how public and internal knowledge will be separated inside Zammad. The safest pattern is to keep public articles and internal procedures in categories that are governed by different access rules, so that visibility is decided by where an article lives rather than by how carefully someone remembered to tick a box on each article. Treat the category structure as a security control, not only as a navigation aid. Agents will reuse internal runbooks, escalation paths and troubleshooting notes, and those documents often contain internal hostnames, vendor escalation contacts or workarounds that should never reach a customer.

Next, map category-level access to your customer segments. If you serve different groups, such as retail customers, business customers under a support contract, and partners, each group may need its own set of articles. Write down which groups can read which categories, who can create and approve articles in each one, and who is allowed to move an article between categories. Then confirm how the Zammad permission model applies to knowledge base content in your installed release, because role, group and organization settings interact and the knowledge base may treat them differently from tickets. Check the current behavior in the Zammad admin documentation and test it with a customer account, an agent account with limited groups, and an administrator account before launch.

The most common failure is publishing internal procedures by mistake. This usually happens when an article is created in a public category during drafting, when an existing internal article is copied into a public category to reuse its text, or when a new category inherits broader visibility than its authors expected. Put an approval step in the process for anything entering a public category, and use a review checklist that asks whether the article names internal systems, people, prices, customer data or unreleased features. Your own environment will determine which of these risks apply, so list them with your support leads.

Plan the monitoring side of this control as well. Review who holds the roles that can publish or change category visibility, and record those changes in your normal change process. If you use single sign-on or directory groups to assign agent roles, a change in the identity provider can change what an agent is able to publish, so include the knowledge base in your access reviews. Also decide how you will remove an article that was published by mistake: who can unpublish it, how quickly that must happen, and whether you need to check search and cached copies for exposure.

Finally, before any AI-assisted drafting from solved tickets is switched on in version 7.2 or later, confirm which categories and roles the drafts will land in and who must review them before publication. Drafts created from tickets can carry customer details into an article, so the same separation rules apply to generated content. Ask your Zammad partner or your own administrators to test this path with sample tickets that contain sensitive data, and confirm the result against the release documentation for your installed version.

How to build the Zammad knowledge base in order

This sequence moves the knowledge base from a confirmed platform decision to a piloted, reviewed set of articles that customers and agents can use. Each step ends with a check so you know what is ready before the next one begins.

  1. Confirm the Zammad version and hosting model

    Confirm which Zammad release you will run and where it will be hosted. Zammad 7.2 adds AI drafting from solved tickets and article suggestions in the ticket sidebar, so if you need those features, confirm that your release line includes them. Decide between self-hosting in your own infrastructure and a hosted plan, because that choice determines who applies patches and who owns backups. Check the software requirements for PostgreSQL, Redis and your reverse proxy before anything else. Done means you have a written version and hosting decision, signed off by the team that will operate the platform.

  2. Define category and audience structure

    Map the knowledge base before writing any articles. Create top-level categories that reflect how customers phrase their questions and how agents organize their queues. For each category, decide whether it is public, internal to agents, or both, and which groups can edit it. Keep the tree shallow enough that a customer can reach an answer in a few clicks. Record the decisions in a short permissions matrix listing category, audience and editors. Done when support leads and a representative from each product area have reviewed the matrix and agreed to it.

  3. Configure languages and the custom URL

    Set the languages you will publish in and configure the custom URL customers will use. Confirm which languages your team can support, because each published language needs its own articles or a clear fallback rule. Point the URL to a hostname you control and make sure DNS and the TLS certificate match it before go-live. Check that the public pages load under the custom URL in every language and that links between articles resolve. Confirm the exact settings path in the admin documentation for your version. Done when a test visitor can open each language version without errors.

  4. Set up publishing and review

    Define how articles move from draft to published. Decide who writes, who reviews and who can publish, and whether scheduled publishing will be used for product changes. Route AI-drafted articles from solved tickets through the same review queue as manual drafts. Reviewers should check facts, tone and any personal data copied from the ticket. Test one article through the full path: draft, review, schedule, publish and unpublish. Done when the test article appears only at the planned time and only to the planned audience.

  5. Enable article suggestions in the ticket sidebar

    Turn on article suggestions in the ticket sidebar so agents see relevant articles while they work. In Zammad 7.2, suggestions use semantic search, so match quality depends on clear, current titles and article content. Confirm that agents with the right roles can see internal articles and that public-only content is not exposed to customers through other channels. Test with three or four sample tickets of different types and record which articles appear for each. Done when the suggestions are relevant and no restricted article appears to a user who should not see it.

  6. Pilot with a subset of agents

    Run a pilot with a small group of agents before opening the knowledge base to everyone. Include agents from different queues and at least one person who is skeptical of new tooling. Ask them to use suggestions and AI drafts on live tickets over a period you agree on in advance. Collect feedback on wrong suggestions, missing articles and drafts that needed heavy editing, then adjust categories and article content based on what you learn. Done when the pilot group reports the suggestions are useful and every open issue has an owner and a due date before the wider rollout.

What the 7.2 AI drafting does and what it does not replace

Zammad 7.2 can generate draft knowledge base answers from solved tickets and suggests relevant articles in the ticket sidebar through semantic search, according to the 7.2 release notes. Treat both features as assistance for agents and editors, not as a source of published content. The drafting feature reads a solved conversation and proposes an answer that someone then has to check, edit and place into the knowledge base. The sidebar suggestions help an agent find an existing article while replying, which is most useful when your article set is already organized into clear categories and titles. Drafts need agent or editor review before publication. A draft can be fluent and still be wrong about a product version, a policy, a price or a step that changed after the ticket was closed. Set a clear rule for who reviews a draft, who approves it for the public knowledge base, and whether internal-only answers can skip the public review step. Decide this before you switch the feature on for the whole team, and record the owner of each knowledge base category so that stale drafts have someone accountable for them.

Your team must also decide which ticket data is acceptable as a source for drafts. Solved tickets often contain personal data, payment details, health information, credentials or internal commentary that should never reach a public article. Review your data classification and your customer contracts, then define which queues, customers or ticket types can feed the drafting feature and which must be excluded. Confirm with Zammad documentation and your own configuration how the feature selects its source tickets and whether you can restrict that selection by group, tag or state. This section covers what the feature does and the review and source decisions around it. It does not cover where the AI processing happens. Zammad AI features that rely on external model endpoints, and the options for running a self-hosted model, are covered on a separate sibling page. Before you rely on any AI feature in production, confirm the current behavior, required settings and data flow for your Zammad version in its release notes and documentation, and test the feature against a copy of your real ticket history with sensitive content in mind.

Security and data handling for a public knowledge base

A public knowledge base exposes whatever it publishes to every visitor, and Zammad 7.2 drafts can pull text from tickets that contain customer data. The controls below cover what gets published, who can see drafts, how publishing is recorded, and how article content is restored with the rest of the database.

Publication risk from article visibility

An article becomes visible to the public once it is published, so a wrong category, an unintended language version or a copied internal detail can reach anyone with the URL. Before launch, test the public view while logged out and confirm which categories and articles appear. Confirm in your own instance how permissions on each category govern what unauthenticated visitors can see, and recheck after every category change.

Separating internal notes from public articles

Internal procedures, escalation paths and agent-only workarounds should live in categories that are not public, not in articles with a hidden flag that someone may later switch off. Review which categories are attached to the public knowledge base and which hold agent-only material. Confirm that agent-only content cannot be reached through the public search or the public URL, using a logged-out test session.

Access control on draft content

Drafts that are not yet published should be visible only to the roles that write and review them. Define who can create, edit, review and publish articles, and confirm that agents without publishing rights cannot see or change drafts they do not own. Test this with a test account in each role, since a permission that looks correct in the administration screens can still expose a draft in search results.

Customer data in drafts generated from tickets

Zammad 7.2 can generate draft answers from solved tickets, and a ticket may contain names, addresses, account numbers or other personal data. Decide whether generated drafts are reviewed by a named role before publication, and require that personal details are removed. Confirm with a sample of solved tickets how the generated text handles identifiers, and document this review step in your procedure.

Audit of who published what

Publication decisions need a record that shows which account created, changed, reviewed and published each article, and when. Confirm which article history and ticket activity entries your Zammad version keeps, and whether they can be exported for review. Agree a retention period with your compliance owner, and test by publishing and then reviewing the trail for a sample article.

Article content in PostgreSQL backups

Zammad stores article content in PostgreSQL 15 or newer, so published and draft articles are included in the same database backups as tickets and users. Confirm that the backup job covers the Zammad database, that restores are tested, and that a restored instance shows the same publication state. Search indexes in Elasticsearch, if used, are rebuilt from the database and should be checked after a restore.

Knowledge base questions buyers ask before hiring help

What drives the cost of a Zammad knowledge base build?

Effort follows how much content you publish, how many audiences and languages it serves, and how much review and governance you need. The cost has three parts. Zammad itself carries no license fee, since it is licensed under the GNU Affero General Public License version 3. Optional self-hosted support subscriptions are sold by Zammad, and its pricing page lists them at 2,999 EUR per year (Business, 6-hour response), 5,999 EUR per year (Enterprise, 4-hour response) and 9,999 EUR per year (Corporation, 2-hour response). The third part is implementation labor, which covers information architecture, permissions, language setup, the custom URL, content migration and review workflows. Labor is mostly one-time, while hosting and any subscription recur each year. DeployOpen quotes follow from written scope, so ask for each deliverable, the assumptions behind it and what is excluded.

How long does a Zammad knowledge base project take?

No single duration applies, because the timeline depends on content volume, the number of languages, the number of approval steps and whether articles must be migrated from an existing wiki or help center. A small public help center in one language with one editor group is a much shorter job than a multilingual library that mixes public and internal content, uses scheduled publishing and needs separate reviewer roles. Ask for a timeline organized into phases: discovery and information architecture, configuration of categories and permissions, content load and testing, then go-live and handover. Confirm which milestones depend on your content owners and approvers, because review delays often become the longest part of the schedule. DeployOpen states timelines in the written scope before work starts.

Can our own team set up a Zammad knowledge base alone?

Yes, an internal team with Zammad administration skills can configure categories, permissions, languages and scheduled publishing, especially for a single public help center in one language. The harder work sits around the configuration: agreeing who owns each category, mapping permissions to customer and agent roles, setting up the custom URL and its certificates, and testing search with actual queries. Elasticsearch is optional but strongly recommended for faster search, reporting and searching email attachment content, so decide early whether your team can run it. Confirm that your team has time for testing with non-admin accounts, since administrators see content that other audiences cannot. A partner is most useful when the scope spans several languages, sensitive internal content or a content migration.

What does our side need to provide for a knowledge base build?

The work depends on access and decisions from your side. Provide an inventory of existing help content that shows where it lives, who wrote it and whether it is still current. Supply a list of audiences such as customers, partners and agents, plus the languages you must publish in. Name an owner and an approver for each category. For the custom URL, confirm who controls the domain and DNS records. Give the team staging access to the Zammad instance you host, along with admin accounts for configuration. If you want AI drafting tested, provide a sample of solved tickets, with personal data handled under your own rules. Expect decisions on brand terms, legal wording for public pages and which content must stay internal. Slow answers at this stage often extend the timeline more than technical configuration does, so agree on a decision owner and a response window in writing.

Does Zammad 7.2 write knowledge base articles from solved tickets?

Zammad 7.2 can generate draft knowledge base answers from solved tickets, and it suggests relevant articles in the ticket sidebar through semantic search, according to Zammad's 7.2 release notes. Treat each draft as material for editors, and do not publish it directly. Plan a review step where an owner checks accuracy, removes customer personal data, adjusts tone and sets the category and audience before anything goes live. Decide which ticket types qualify, since drafts from unusual cases can add noise to the library. Confirm which model or endpoint the feature uses and where ticket text is processed, because that decides your data handling. Test the sidebar suggestions with a sample of recent tickets to see whether the suggested articles match what agents would pick by hand.

How should categories and permissions be designed for public and internal articles?

Start by listing each audience and what it may see, then map those audiences to Zammad roles and groups before you create categories. Keep public and internal content in separate categories so that one permission change cannot expose an internal article by accident. Split the publishing workflow into drafting, review and publishing, and reflect that split in roles. Test each audience with an account that holds the same role, because administrators see more than other users. Check that the public help center shows only published public articles. Also confirm that search results and sidebar suggestions respect the same boundaries. Document the permission model so that future category changes follow the same rules and are reviewed before they take effect.

What usually goes wrong in a Zammad knowledge base rollout?

Most problems trace back to unclear ownership and thin testing. Common failures include articles with no owner or review date, so content goes stale; public pages that show to the wrong audience after a permission change; languages published only partly, so customers land on missing translations; custom URL and certificate problems found only at launch; search tested only with administrator accounts; and scheduled publishing that runs at an unexpected time because the time zone was not checked. Each of these can be prevented with a short checklist. Assign an owner to every category, set a review interval, test each audience with a matching role, and run a pre-launch test of the custom URL. Confirm the scheduled publishing time zone behavior in your installed version before you rely on it.

What should a DeployOpen quote for knowledge base work include?

A DeployOpen quote follows from the written scope, so it should list the deliverables, the Zammad version and hosting environment, the languages, the planned number of categories, the expected content volume, the client responsibilities, the acceptance criteria and what is excluded. Most engagements are fixed scope, with scope, deliverables and timelines agreed in writing before work starts. Ask whether editor training, AI drafting setup and content migration are included or priced separately. Ask how changes after launch are handled. Ongoing support, upgrades and testing are available as retainers, so ask whether article reviews and version upgrades belong in a retainer. DeployOpen does not publish a price list, so compare quotes by their scope. Confirm whether any Zammad support subscription is part of the quote or bought separately.

When to postpone the knowledge base project

Postpone the Zammad knowledge base build if you cannot name who owns the content, which categories it will sit under and how articles will be reviewed. A knowledge base is only as useful as the answers in it, and in Zammad every article is published under a category with its own permissions, so an empty or ambiguous category tree produces articles that are hard to find, duplicated, or visible to the wrong audience. Before any configuration work, confirm a named content owner who can approve articles for both the public and internal sections, and confirm that the owner has time allocated for this role, not just a title on a plan.

Ticket categories come next. If your agents cannot agree on how tickets are classified today, the knowledge base will inherit that confusion. Pull a sample of recent tickets and check whether the existing groups, states and tags map to the questions customers actually ask. If a large share of tickets fall into a catch-all category, fix the ticket taxonomy first, because the category and article structure, the search suggestions in the ticket sidebar and any AI drafting from solved tickets all depend on consistent classification. Treat that as a precondition, not a side task.

Identity and channel decisions also gate the project. Article permissions depend on who the user is: a customer, an agent, or an agent in a specific group. If the decision on how customers sign in, whether through a directory, a social login or a plain account, is still open, you cannot test whether a private article stays private. Similarly, if it is undecided which channels (email, web form, chat or phone) create tickets that should link to articles, the answers you publish will not match the paths customers use. Settle the identity provider integration and the channel list, then build the knowledge base against them.

Finally, check for an agreed review process. Decide how often articles are reviewed, who retires outdated content, and how scheduled publishing will be used so that launch dates are not missed. Without this, the first product change makes half the articles wrong and nobody notices until customers complain. If you cannot commit to a review cadence, start with a small set of articles for the most frequent questions, and defer the wider build until that cadence is working. Ask your Zammad partner to write these checks into the scope so that the decision to proceed or wait is made on evidence rather than on the calendar.

How DeployOpen scopes and supports your Zammad knowledge base

DeployOpen plans, builds, documents and supports Zammad knowledge bases inside infrastructure you control. Each engagement starts with a written scope that defines which categories, audiences, languages and publishing rules go live, and ongoing support is available as a retainer.

How we scope

  • We map which knowledge base categories are public, internal or restricted, and which groups hold each permission.
  • We agree the languages, custom URL and branding the knowledge base will use before any configuration begins.
  • We confirm whether the 7.2 AI drafting from solved tickets and sidebar article suggestions are in scope, and who reviews drafts.

How we build

  • We configure categories, article templates and permissions in a test instance matched to your planned production setup.
  • We set up scheduled publishing and check that articles appear only to the audiences defined in the scope.
  • We test the public portal and agent sidebar with representative tickets, including search results in each agreed language.

How we hand over

  • We document the category model, permission matrix, publishing workflow and the review steps for AI-drafted answers.
  • We train the staff who will write, approve and retire articles, using your own categories and sample tickets.
  • We deliver a written record of what was built, tested and left out of scope, so your team can maintain it.

How we support

  • Retainers cover ongoing article governance, permission changes and reviews of new Zammad releases that affect the knowledge base.
  • We plan knowledge base changes alongside Zammad upgrades so that custom URLs and permissions survive each update.
  • Ask us to confirm response times and support terms in writing, as they depend on the retainer or subscription you choose.

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.