Zammad security hardening

Zammad security hardening covers the reverse proxy, the application, PostgreSQL, Redis and Elasticsearch, and the patch process that keeps them current. This page explains the decisions, build order, effort drivers and checks that close each step.

On this page

Why Zammad security hardening starts before the first ticket

Zammad security hardening means designing protection for the entire helpdesk stack before agents start working in it. A self-hosted Zammad instance holds customer emails, attachments and personal data in infrastructure you run, so the work covers every layer that stores or moves that data. Changing a default setting in the application is one small step within it, and the rest depends on decisions about how the pieces connect and who can reach them. The attack surface spans several components. The web tier is an Nginx or Apache reverse proxy that terminates TLS. The Zammad application serves agents, customers and the API. PostgreSQL 15 or newer stores the content, and Redis 7 or newer carries realtime websocket traffic. Elasticsearch is optional but strongly recommended for search and for searching attachment content, so it holds a copy of data that needs the same care. Memcached becomes relevant when you run multiple instances, such as containers or cluster nodes. Each component has its own configuration, network exposure, access model and patch path, and each should appear in your hardening plan by name. Patching is the element most likely to slip. Zammad publishes fixes on more than one release line at once. Version 7.2 was released on 23 September 2026, followed by security releases 7.2.1 on 6 October 2026 and 7.2.2 on 8 October 2026. Security release 6.5.5 followed on 15 October 2026, so fixes were published for both the 6.5 and 7.x lines in parallel. Before go-live, confirm which line you will run, how you will learn about security releases, and how quickly your change window allows you to apply them across every component. When you self-host, your team owns the whole stack. That includes the operating system, the reverse proxy, PostgreSQL, Redis, any Elasticsearch or Memcached nodes, backups, certificates and access accounts. Zammad has no license fee for self-hosted use, but the staff time for these tasks is a real cost to plan for. A support subscription covers the Zammad application, so ask any provider to state in writing which layers they support and which remain your responsibility. A hardening pass is far easier to design once than to retrofit after go-live. Decisions about TLS termination, which network segments can reach the database and cache, administrator and agent roles, password and two-factor policies, and logging all affect live email routing and user logins. Make those decisions before the first ticket arrives, record them, and test them in a non-production instance so that changes later do not disrupt agents and customers.

Which Zammad components carry the attack surface

A Zammad installation is a set of cooperating services, and each one stores different data or accepts different traffic. Hardening starts by listing which component holds what, which parts face users or other networks, and which control applies to each. The cards follow that path, from the application outward to the shared services behind it.

Zammad application and its paths

The Zammad application serves the agent interface, the customer portal, the API and the websocket path that carries realtime updates. It holds tickets, customer contact details, attachments and configuration, so every user reaches it directly. Confirm which paths are exposed to the internet, limit access to administrative functions to known networks where your proxy rules allow it, and confirm the service runs under a non-root account. Keep the instance on a current security release.

Reverse proxy in front of Zammad

Zammad supports Nginx or Apache as the reverse proxy, and this layer terminates TLS for every browser and API client. It also decides which headers, request sizes and websocket upgrades reach the application. Review the TLS protocol and cipher configuration, enforce HTTPS redirects, and set upload size limits that match your attachment policy. Confirm that forwarded client headers are set only by the proxy, and apply log retention to proxy logs that matches your application logs.

PostgreSQL database

Zammad stores its content in PostgreSQL 15 or newer, so the database holds the full ticket history, user records and stored password hashes. Key levers are network access limited to the application hosts, a dedicated database role with only the privileges Zammad needs, and encrypted connections where your topology allows them. Encrypt database backups, test restores on a schedule, and confirm your server version meets the 15 or newer requirement. Patch the database server on its own cycle.

Redis for realtime traffic

Zammad requires Redis 7 or newer for realtime websocket communication, so Redis carries live session and notification traffic between Zammad processes. It should never be reachable from user networks. Confirm that Redis listens only on private interfaces, that client authentication is enabled, and that network rules allow access only from Zammad nodes. Treat any exposure as a risk to active sessions, and review these rules after every change to network topology.

Elasticsearch for search and attachments

Elasticsearch is optional but strongly recommended for faster search, reporting and searching the content of email attachments. Teams that deploy it must apply the controls below, and teams that do not should record that decision. An Elasticsearch deployment indexes ticket text and attachment content, so restrict its network access to Zammad nodes, enable authentication and transport encryption that your version supports, and protect index snapshots like database backups.

Memcached for shared state

Memcached is needed for multi-instance deployments such as containers or cluster nodes, where instances share cached state. Single installations can use the file system cache instead, which removes this component from the attack surface. Where Memcached is deployed, keep it on a private network segment reachable only from Zammad hosts, and confirm which access controls your version and packaging enable. Do not assume defaults are sufficient, and confirm that the cache holds no secrets beyond what your design requires.

Which hardening choices fit your risk and staffing

This table compares four hardening decisions for a self-hosted Zammad: where TLS terminates, how database and search services are segmented, how users authenticate, and how security releases are applied. Read each row by matching your risk tolerance and team capacity to the operational cost listed, then decide which options your team can run every month.

DecisionWhen it fitsOperational cost to plan for
TLS at Nginx or Apache on the Zammad hostSmall teams with one instance, a single owner for the web server, and no existing edge load balancerCertificate renewal and proxy configuration sit with your team; you must keep proxy headers and websocket forwarding correct through upgrades
TLS at an upstream load balancerOrganizations already running a managed or shared load balancer with central certificate management and WAF rulesRelies on the load balancer team; confirm end-to-end encryption to Zammad and that forwarded client IP and protocol headers reach the application
PostgreSQL, Redis and Elasticsearch on private segmentsTeams handling customer personal data or regulated support records where database access must be limited to the Zammad applicationNetwork policy and firewall rules need upkeep whenever hosts, ports or scaling change, and troubleshooting takes longer across segments
Shared service network for backing servicesSmaller deployments where a shared database or search cluster already exists and is monitored by a platform teamBroader reachability raises the value of strong service credentials and host hardening; confirm who can reach the backing services from other workloads
Zammad built-in password and two-factor settingsDeployments with few agents, no central identity provider, or a need to run without an external dependencyYour team owns password policy, account recovery and two-factor enrollment support; review these settings against your written access policy
SAML or OpenID Connect with the identity provider's MFAOrganizations that already enforce MFA, joiner and leaver processes and role assignment centrallyIdentity provider outages can block agent logins, so plan break-glass administrator access and confirm certificate or client secret rotation dates
Security releases in a scheduled windowTeams that need change control and staging tests before production, and can accept a known gap between publication and deploymentStaging environment and test time are recurring costs; someone must watch release notes and track which security fixes are still pending
Security releases applied on publicationTeams with a tested pipeline, a named on-call owner and low tolerance for exposure to published vulnerabilitiesRequires fast staging checks and a rollback plan; customizations, triggers and integrations must be retested quickly, which needs skilled staff on short notice

How to harden a self-hosted Zammad in sequence

This sequence takes a self-hosted Zammad instance from an unknown state to a documented, patched and access-limited deployment. Each step closes with a check, so the team can show what changed and what was verified.

  1. Inventory versions and exposed endpoints

    The administrator records the running Zammad version, the PostgreSQL, Redis, Elasticsearch and reverse proxy versions, and every hostname and port that answers. Ask the platform owner to confirm which services sit behind the proxy and which listen directly on a network interface. The step is done when the team has a written inventory of each component, version and listening port, and an external scan of the public address matches that list. Any port the inventory does not explain is a finding to resolve before the next step.

  2. Confirm the release line and apply security releases

    Compare the installed version with the Zammad releases page and identify whether the instance is on the 7.2 or 6.5 line. Apply the latest security release for that line, using the upgrade path in the Zammad documentation and a staging copy first. The releases page lists 7.2.2 and 6.5.5 among recent security releases, so confirm the newest patch for your line on the day you apply it. The step closes when the admin interface or the version file reports the patched release and the team has a note of the change window and rollback plan.

  3. Terminate TLS at the reverse proxy

    Configure Nginx or Apache as the single public entry point, with a certificate issued by your internal or public certificate authority and modern protocol settings. Redirect plain HTTP to HTTPS, set the Zammad external URL to the HTTPS address, and confirm that websocket traffic passes through the proxy. Restrict the Zammad application server so it accepts connections only from the proxy. The step closes with a TLS configuration test against the public hostname, which should show the expected protocols and cipher suites and no certificate warnings.

  4. Restrict database, Redis and Elasticsearch ports

    Place PostgreSQL, Redis, Elasticsearch and any Memcached service on the application network only, with firewall or security group rules that allow connections from the Zammad application hosts. Remove any default or public binding and require authentication on Redis and Elasticsearch where the chosen version supports it. Confirm the exact settings with your database and search administrators. The step closes with a port scan from a host outside the application network, which should find none of these services open, and a repeat scan from inside the network that confirms the application hosts can still connect.

  5. Configure identity and the login policy

    Decide whether agents and customers sign in through SAML or OpenID Connect from your identity provider, or through the built-in login with a password policy. Where SSO is used, require it for agents, keep a documented break-glass administrator account, and confirm that two-factor authentication is enforced at the identity provider. Where built-in login is used, set the password and two-factor rules in the admin settings and review session timeouts. The step closes with a login attempt using an account that should be blocked, such as a disabled user or a user outside the permitted group, which must fail.

  6. Design roles with least privilege

    Map each job function to a Zammad role and group, starting from the minimum access each team needs for its queues. Limit administrator rights to named people, separate ticket editing from system settings, and review who can see sensitive groups or customer organizations. Document the design so future changes go through a review. The step closes with a login attempt by a test agent whose role does not permit an administrative action, such as changing system settings or viewing a restricted group. The attempt must be refused, and the refusal must appear in the logs.

  7. Enable logging and encrypt backups

    Turn on application and proxy logging, forward them to a central log store under your retention policy, and confirm that logs do not contain passwords or session tokens. Set up scheduled backups of PostgreSQL and the Zammad file storage, and encrypt the backup files with keys held outside the application host. Confirm with the backup owner where keys are stored and who can restore. The step closes with a restore test into a separate environment, after which the team checks that the restored instance logs in and that a sample ticket and attachment are readable.

Access control, password and two-factor policy for Zammad

Zammad holds customer conversations, personal data and the credentials that connect it to PostgreSQL, Redis, mail servers and search. Access control covers who can sign in and how strongly they prove it, what each agent can see, and where the connection secrets live. The controls below are the ones to review before go-live and again after each upgrade.

Password and two-factor enforcement

Decide which password and two-factor settings apply to agents and administrators, then confirm in the Zammad admin documentation for your installed version which options exist and what their defaults are. Check that two-factor is required for every privileged account, not only offered. Test the sign-in path with a new agent account before go-live, including password reset and recovery codes.

Limiting administrator accounts

Keep the number of administrator accounts small and name each holder, so every privileged change can be traced to a person. Separate day-to-day agent work from administration by giving administrators a second, dedicated account where your policy requires it. Review the list at each staff change and remove accounts that no longer have a business owner.

Least-privilege groups and roles

Design groups around the queues and customer populations each team actually handles, then assign roles that grant only the access those tasks need. Agents who handle billing questions should not see HR or legal queues by default. Test the design with one account per role and confirm that restricted queues do not appear in search, notifications or reports for other groups.

Secrets for database, Redis and SMTP

Keep the PostgreSQL password, Redis credentials, SMTP credentials and the Elasticsearch connection details out of shared configuration files and version control. Store them in your secrets manager or as environment-level values injected at runtime, with restricted read access. Rotate them on a schedule you define, and confirm the exact variable or setting names for your version in the Zammad documentation.

Review of access and secret changes

Record who changed roles, group membership, authentication settings and stored secrets, and keep that record outside the Zammad host where possible. Check the log of administrator actions after each upgrade and after any change to login providers. Ask your partner or internal team to confirm which events Zammad logs by default and which need your own log forwarding.

How hardening changes on single node, HA and Kubernetes

On a single node installed from the package, the host operating system is the main platform layer. Most hardening stays on one server, so the team that owns the host also owns the reverse proxy, firewall and patch path. Zammad's own settings, such as password, two-factor and role policies, remain the application owner's job in the admin interface.

  • Platform layer: host firewall rules that expose only the reverse proxy ports, and operating system patching scheduled around Zammad releases.
  • Platform layer: TLS terminated at Nginx or Apache, with certificate renewal handled on the host.
  • Zammad responsibility: password policy, two-factor enforcement, least-privilege roles and group access.
  • Zammad responsibility: applying minor and security releases according to the release notes.
  • Zammad responsibility: PostgreSQL and Redis access, which stays local but still needs credentials and restricted listening addresses.

Check that the database and Redis services listen only on local interfaces and that the firewall policy matches the reverse proxy configuration you tested.

How to test that Zammad hardening holds and fails safely

Every hardening control in a self-hosted Zammad deployment should be checked by someone other than the person who configured it, and each check should have an expected result written down before it runs. Start at the edge. Test the TLS configuration on the Nginx or Apache reverse proxy from outside your network, confirm that the certificate chain is complete and trusted by the clients your agents and customers use, and confirm that plain HTTP either redirects to HTTPS or is refused. Then confirm that the application itself is only reachable through the proxy, not on its application port from the public side. Use an external scanner or a second network vantage point for this, since a check run from inside the same subnet will tell you little about what an attacker sees.

Next, confirm that the backing services are unreachable from anywhere they should not be. PostgreSQL, Redis and Elasticsearch should accept connections only from the Zammad application nodes on the application network. Run a port scan from the internet-facing segment, from a user workstation network and from a host in the application tier that is not a Zammad node. Also check the Redis configuration for authentication and bind addresses, because Redis is used for realtime websocket communication and an exposed instance is a common finding. Confirm the Elasticsearch cluster does not answer on its HTTP port outside the private network. Record the exact scan results, not a summary.

Test the policies by trying to break them. Attempt to set passwords that violate the configured minimum length, complexity or reuse rules, and confirm each attempt is rejected with a clear message and that the attempt is logged. Enable two-factor authentication for a test agent, then attempt login with a wrong code, an expired code and a replayed code. Confirm that repeated failures lock or slow the account according to your policy, and that recovery codes and reset flows cannot bypass the second factor. Repeat the role tests for each group: sign in as an agent who belongs to one group and try to open, search for, merge or reply to tickets owned by another group, both directly by URL and through the API. A permission test that only uses the web interface misses API access, so include both.

Fail-safe tests show what happens when a control or dependency breaks. Stop Redis on the staging copy and observe whether Zammad degrades in a way that stops users from acting on stale data, or whether it returns errors that leak internal hostnames. Stop Elasticsearch and confirm that core ticket creation and viewing still work, that search fails with a controlled message, and that no ticket data is written to an unexpected location while the index is unavailable. Check whether sessions expire after the inactivity period you configured and after logout, and whether a session token remains valid after a password change. Trigger error pages deliberately, using malformed requests and missing records, and confirm that responses do not display software versions, stack traces, file paths or database errors.

Run this full set on a staging copy that matches production configuration, after each security release and before any change to the proxy, database or role model. Zammad has published security releases in parallel on more than one line, so a release for the version you run may arrive while you are busy with another line; check the Zammad releases page for each one and treat its arrival as a trigger for the test cycle. Keep the test scripts, scanner configuration, timestamps, tester names and results in a dated record. This record is the evidence an auditor or internal reviewer will ask for, and it is also how you show that hardening held after an upgrade. Ask your implementation partner to confirm in writing which of these tests they will run, which they expect you to run, and how failures are reported and retested.

What drives Zammad security hardening effort

This table lists the factors that raise or lower the work of hardening a self-hosted Zammad, with a practical way to keep each one contained. Read each row as a lever: the cost is driven less by the hardening steps themselves than by how many roles, integrations, environments and evidence obligations the team must carry. Keeping those counts low is usually the most effective way to control effort.

DriverWhy it changes effortHow to keep it down
Agents and groups needing role designEach group with different ticket access needs its own permission review, and each new role must be tested for least privilege.Start from a small set of standard role templates and add exceptions only when a documented need exists.
Channels and external integrationsEmail, chat, forms, phone and API integrations each open network paths and credentials that need review and monitoring.Enable only the channels in use, document each inbound and outbound path, and rotate integration credentials on a schedule.
Identity provider complexityMultiple identity providers or mixed local and federated accounts multiply login policies, provisioning rules and role mapping.Use one identity provider for agents where possible, enforce two-factor policy centrally, and limit local accounts to a break-glass set.
Elasticsearch, Memcached and multi-instance hostingEach optional backend adds its own hardening, network restrictions and patching, and multi-instance hosting requires shared cache configuration.Decide scope early, restrict backend access to Zammad hosts only, and confirm the requirements for your Zammad version with the vendor documentation.
Number of environmentsProduction, staging and test each need the same hardening, so changes must be applied and verified in every environment.Codify configuration in version control so the same settings deploy to each environment with only documented differences.
Customizations retested after security releasesTriggers, macros, custom attributes and integrations may behave differently after a security fix and need regression checks.Keep customizations documented and small, and maintain a repeatable test list that runs before each release is applied.
TLS and certificate renewalManual certificate handling at the reverse proxy creates expiry risk and extra change work across environments.Automate certificate issuance and renewal at the reverse proxy and monitor expiry dates centrally.
Compliance program evidenceEach control the assessor expects needs a configuration record, change history and proof of review, which adds recurring collection work.Agree the evidence list with your assessor early and generate it from configuration, logs and change records where possible.

Keeping Zammad patched and documented after go-live

The hardening work does not end at go-live. Someone must own the release watch, and that owner needs to know which release line each Zammad instance runs. Zammad published security releases for two lines in parallel: 7.2.1 on 6 October 2026 and 7.2.2 on 8 October 2026 for the 7.2 line, and 6.5.5 on 15 October 2026 for the 6.5 line. An instance on 6.5 cannot wait for a 7.2 patch, and a 7.2 instance does not receive 6.5 fixes. Subscribe to the Zammad releases page, record the line and version of every instance, and assign a named person to read each advisory the day it appears. Every security release should pass through a staging copy before production. Rebuild staging from current production configuration, including the reverse proxy settings, the Redis and PostgreSQL connection details and the Elasticsearch and Memcached settings where they apply. Then retest the paths that a patch can break: agent and customer login, any SAML or OpenID Connect sign-in, inbound email and outbound notifications, attachment upload and download, and a search that depends on Elasticsearch. Time the rebuild on your own hardware and record it, because that figure becomes your planning input for the next emergency. Two routine checks catch problems that patches do not fix. First, monitor TLS certificate expiry on the reverse proxy, whether it runs Nginx or Apache, and alert well before the expiry date so renewal is never an emergency. Second, review admin accounts and failed logins on a fixed schedule. Confirm that every administrator still needs the role, that departed staff are disabled, and that repeated failed sign-ins are investigated against the password and two-factor policy you set. Keep the review date and the reviewer's name in the same record as the patch log. Backups need a restore test, not just a successful backup job. Restore the PostgreSQL database and the attachment store into a separate environment at least on a regular cycle, then open tickets with attachments and confirm they render. Confirm with your team whether the Elasticsearch index is restored from backup or rebuilt after restore, because that choice affects recovery time. Record the last successful restore test, its result and any gaps. The documentation set should contain four items: the hardening baseline, a version and release date log for each instance, a register of exceptions with an owner and review date for each one, and a written emergency patching procedure stating who approves an out-of-cycle change, what staging shortcut is acceptable, how to roll back, and who informs agents. If you buy a self-hosted support subscription, the pricing page lists annual fees of 2,999 EUR (Business), 5,999 EUR (Enterprise) and 9,999 EUR (Corporation) and response targets of 6, 4 and 2 hours. Before relying on a tier, confirm in writing whether it covers security releases, emergency assistance, and components outside Zammad such as PostgreSQL, Redis and Elasticsearch.

Questions buyers ask about Zammad security hardening

How much work does Zammad security hardening take?

The effort depends mostly on how many controls are already in place and how many systems sit around Zammad. The main drivers are the number of Zammad instances, whether the reverse proxy, PostgreSQL, Redis and Elasticsearch are already configured to a secure baseline, how many roles and identity providers must be mapped, and how much testing your change process requires. Cost components: you pay for planning, configuration, verification and documentation of the agreed scope. Hardening is largely one-time work, while security releases and periodic re-checks recur. DeployOpen does not publish prices, so a quote follows from a written scope. Ask for the quote to list each control area separately so you can see what drives the total.

Can our internal team harden Zammad without outside help?

Yes, many internal teams can, provided they have engineers comfortable with Linux, TLS at a reverse proxy such as Nginx or Apache, PostgreSQL 15 or newer, Redis 7 or newer, and SAML or OpenID Connect federation. The harder parts are usually not the settings themselves but the decisions around them: agent and administrator role design, password and two-factor policy choices that match your identity provider, and proving that each control works after upgrades. Teams that run this with internal staff often underestimate the testing and documentation effort. Outside help is most useful when the team lacks time, when there is no staging copy to test against, or when evidence must be assembled for an assessment.

What do we need to provide for a hardening engagement?

Expect to provide four things before work starts. First, access to the infrastructure that runs Zammad, including the reverse proxy, database, search and cache hosts, under your change control. Second, administrators for your identity provider who can confirm SAML or OpenID Connect settings and test sign-in. Third, a staging copy of Zammad that matches production as closely as practical, so changes can be tested before they reach agents and customers. Fourth, a named business owner who can decide role design, approve least-privilege permissions and sign off on password and two-factor policies. Confirm these items in the written scope, along with who performs each step and how changes are approved.

How long does Zammad hardening take in general terms?

Duration follows the scope rather than a fixed template, so no general timeline applies to every environment. The main factors are the number of Zammad instances and hosts, whether Elasticsearch, Redis and Memcached are in scope, how many roles and integrations need review, how quickly your business owner can decide policies, and how long your change board takes to approve production changes. Testing windows also matter, especially when a staging copy must be refreshed first. Ask for a timeline in the written scope that lists dependencies on your side, such as access grants, identity provider changes and approval dates, so delays can be traced to a specific step.

Does hardening Zammad make us compliant with a security standard?

No. Hardening can put controls in place and prepare the configuration records and evidence that an assessment will need, but it does not make Zammad or your organization compliant. Independent auditors and certification bodies issue any audit report, attestation or certification, and DeployOpen does not issue those. Before work starts, map the hardening items to the control identifiers in your framework, such as the relevant control IDs in your ISO/IEC, PCI DSS, SOC or HITRUST requirements, and confirm with your assessor which evidence they expect. Ask your assessor early, because the evidence format they accept can change which records you need to keep.

How do Zammad security releases affect the hardening schedule?

Security releases can change the baseline you hardened against, so they need a planned place in the schedule. Zammad published security releases 7.2.1 on 6 October 2026 and 7.2.2 on 8 October 2026 on the 7.x line, and security release 6.5.5 on 15 October 2026 on the 6.5 line. Confirm which line your instance runs and monitor the Zammad releases page for new security releases. Build a test cycle in staging for each release, then re-verify TLS, authentication and role settings after the upgrade. Include this recurring work in the scope so the hardened state is maintained, not just achieved once.

What should our engineers check after Zammad hardening is complete?

Engineers should check each control against a written test, not a memory of the change. Core checks:

  • TLS terminates at the reverse proxy with current protocol and cipher settings, and plain HTTP redirects.
  • PostgreSQL 15 or newer and Redis 7 or newer accept connections only from Zammad hosts.
  • Elasticsearch, if used, is not reachable from user networks.
  • Password and two-factor policies match the identity provider and the business owner's decision.
  • Test accounts for each agent and administrator role confirm least-privilege access.
  • Logs record administrator changes and authentication events, and someone reviews them.

Keep the results in a dated record so that each security release can be compared against the same checklist.

How DeployOpen scopes, hardens and hands over Zammad security work

DeployOpen scopes Zammad security hardening as a written, fixed-scope engagement inside your own infrastructure, covering the reverse proxy, application settings, database and search backend. We harden, test, document and hand over each item, and ongoing support is available as a retainer. Work is agreed in writing before it starts, so you can review every control, test and deliverable before committing.

How we scope

  • Written scope lists each Zammad host, reverse proxy, PostgreSQL, Redis and Elasticsearch component in your environment.
  • We confirm current release lines and the security advisories that apply before any change is planned.
  • Scope records which accounts, roles and authentication methods are in use, including any SSO integration.

How we build

  • Configure TLS termination at the Nginx or Apache reverse proxy, with certificate handling agreed with your team.
  • Set password and two-factor policies and review least-privilege roles for agents, administrators and customers.
  • Lock down PostgreSQL 15 or newer, Redis 7 or newer and Elasticsearch access to the Zammad components only.

How we hand over

  • Test each control in a non-production copy first, then apply it in your environment with a rollback step.
  • Document each setting, its reason and its verification steps so your team can repeat or audit it.
  • Deliver evidence for compliance assessments; independent auditors and certification bodies issue any formal reports.

How we support

  • Apply Zammad minor and security releases on an agreed schedule, including fixes published for parallel release lines.
  • Re-check TLS, authentication and database settings after upgrades, since configuration changes can drift.
  • Ongoing support is available as a retainer, and engagements are fixed-scope with written deliverables agreed up front.

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.