XWiki Standard vs XWiki Enterprise: Key Differences Explained

XWiki Standard: A Complete Guide for Administrators—

Introduction

XWiki Standard is a flexible, open-source wiki platform designed for collaborative knowledge management, documentation, and internal knowledge bases. It’s built on a modular architecture that supports extensions, customization, and enterprise-grade deployment patterns while remaining accessible to smaller teams. This guide covers installation options, configuration, user and rights management, content organization, extensions and apps, backup and maintenance, security best practices, performance tuning, and tips for scaling and troubleshooting.

Installation and Deployment Options

System requirements

Java (OpenJDK 11 or later commonly recommended).
A servlet container such as Tomcat or an application server (Tomcat 9+ typical).
A relational database: H2 for testing, PostgreSQL or MySQL/MariaDB recommended for production.
Adequate RAM (2–4 GB minimum for small deployments; 8+ GB recommended for larger teams).
Storage for attachments and backups (size based on content volume).

Deployment choices

Standalone with embedded H2 — quick for evaluation and demos.
Tomcat + external relational database — recommended for production.
Docker images — convenient for containerized deployments and reproducible environments.
Cloud hosting — deploy on AWS, Azure, GCP, or managed Kubernetes clusters.

Installing using Tomcat + PostgreSQL (concise steps)

Install Java and Tomcat.
Create PostgreSQL database and user (encoding UTF-8).
Download XWiki Standard WAR and place it in Tomcat’s webapps folder.
Configure database connection in web.xml or xwiki.cfg if needed.
Start Tomcat and complete initial setup via web UI.
Configure file storage (attachments) and mail settings.

Initial Configuration and Site Setup

Global configuration files

xwiki.cfg — main configuration file for runtime parameters.
xwiki.properties — data storage and miscellaneous properties.
xwiki.hsql (if using H2) — embedded DB settings.
web.xml and tomcat context files — servlet and container settings.

Basic site settings via UI

Set wiki name, default language, and base URL.
Configure mail SMTP for notifications.
Set default skin and look & feel.
Configure authentication mechanisms (LDAP, OAuth2, SSO).

Users, Groups, and Rights Management

Authentication options

Built-in XWiki authentication for local users.
LDAP/Active Directory integration for centralized user directories.
OAuth2 / SAML / OpenID Connect for single sign-on.
External authentication via reverse-proxy headers.

Authorization model

Rights assigned at wiki, space, and page level.
Predefined rights: view, edit, comment, delete, admin, etc.
Use groups to grant consistent permissions to sets of users.
Deny rules override allow rules — design accordingly.

Best practices

Use groups for permissions rather than per-user rights.
Create role-based groups (e.g., Admins, Editors, Readers, Guests).
Limit global admin accounts; use service accounts where appropriate.
Regularly audit permissions and membership.

Content Organization and Editing

Wiki structure

Wikis > Spaces (namespaces) > Pages.
Use clear naming conventions and hierarchical spaces for teams/projects.
Templates and page blueprints help standardize content.

Editing and macros

WYSIWYG editor for non-technical users; source editor for advanced formatting.
Use macros (Velocity, XWiki Syntax macros) to embed dynamic content.
Create templates and page blueprints for recurring page types (meeting notes, policies, how-tos).

Versioning and history

Every page has revision history and diff view.
Use page comments and in-page annotations for collaborative editing.
Restore older revisions if needed.

Extensions, Apps, and Customization

Extensions ecosystem

XWiki Extension Manager allows install/uninstall of apps and macros.
Popular extensions: App Within Minutes, Task Lists, Blog App, Office Importer, PDF Export.
Community and marketplace provide both free and commercial extensions.

Developing custom apps

Use App Within Minutes for no-code apps (forms, objects, lists).
For advanced apps, develop extensions using Java, Groovy, or Velocity.
Leverage REST APIs for external integrations.

Customization points

Skins and UI themes for look & feel.
Custom wiki pages for dashboards and navigation.
Use JavaScript/CSS assets carefully—avoid breaking core upgrades.

Backup, Maintenance, and Upgrades

Backup strategy

Backup database regularly (logical dumps + binary backups for large DBs).
Backup attachment storage and configuration files.
Test restores periodically to validate backup integrity.

Maintenance tasks

Clean up old revisions and attachments to save space (use provided maintenance scripts or extensions).
Monitor logs (catalina.out, xwiki logs) for errors and warnings.
Keep Java and Tomcat patched.

Upgrading XWiki

Review release notes and compatibility before upgrading.
Test upgrades in a staging environment.
Backup database and files before applying upgrades.
Use the recommended upgrade path for major version changes.

Security Best Practices

Keep XWiki, Java, servlet container, and OS updated.
Enforce HTTPS/TLS for all connections; redirect HTTP to HTTPS.
Use strong passwords and integrate with centralized authentication (LDAP/SSO).
Limit admin privileges and use least privilege principle.
Enable logging and monitor for suspicious activity.
Configure CSP (Content Security Policy) and X-Frame-Options headers.
Sanitize user input in custom extensions; avoid enabling risky script execution for untrusted users.

Performance Tuning

Caching

Enable and tune XWiki cache settings (cache sizes in xwiki.cfg).
Use HTTP caching headers and reverse proxies (Nginx, Varnish) for static assets.

Database tuning

Use connection pooling (Tomcat JDBC pool).
Tune DB settings (work_mem, shared_buffers for PostgreSQL).
Index frequently queried columns if necessary.

Scaling

Vertical scaling: increase CPU/RAM for Tomcat server.
Horizontal scaling: run XWiki in a clustered setup with shared storage for attachments and a central database.
Use load balancer and sticky sessions or session replication if clustering.

Monitoring and Troubleshooting

Key metrics to monitor

Response time, throughput, error rates.
JVM memory usage (heap/GC), CPU, thread counts.
Database query performance and slow queries.
Disk I/O and storage usage for attachments.

Troubleshooting tips

Reproduce issues in staging.
Check XWiki logs and Tomcat logs for stack traces.
Increase logging temporarily for deeper insight.
Roll back recent configuration changes or extensions when diagnosing regressions.

Governance and Adoption

Content governance

Define content lifecycle: creation, review, archival.
Assign content owners for spaces/projects.
Use templates, labels, and metadata to standardize content.

Encouraging adoption

Provide onboarding guides and templates for contributors.
Run training sessions and create a “How to contribute” page.
Feature highlights and newsletters to show value.

Example Admin Checklist (quick)

Install and configure Tomcat, Java, and PostgreSQL.
Configure SMTP, base URL, and default language.
Integrate with LDAP/SSO if required.
Set up groups, roles, and basic permissions.
Install essential extensions (Office Importer, PDF Export, App Within Minutes).
Configure backups and test restores.
Enable HTTPS and security headers.
Monitor logs and set up basic alerts.

Conclusion

XWiki Standard offers a powerful, extensible platform for building knowledge bases and collaborative intranet sites. Administrators should focus on secure deployments, thoughtful content architecture, routine maintenance, and encouraging user adoption to get the most value. With proper configuration, monitoring, and governance, XWiki can scale from small teams to large organizations while remaining highly customizable.