Deploying Docmost on a VPS: The Lightweight, Go-Powered Real-Time Collaborative Wiki for Development Teams

Introduction: The Search for the Perfect Team Wiki

In modern software development, seamless documentation is just as critical as clean code. Development teams need a centralized knowledge base to store architecture designs, API contracts, deployment guides, and sprint notes. While platforms like Confluence and Notion are industry standards, they often come with significant drawbacks: high subscription costs, heavy memory consumption, and data privacy concerns.

Enter Docmost—an open-source, ultra-lightweight collaborative wiki and documentation platform written in Go. Designed specifically for speed, simplicity, and real-time collaboration, Docmost provides a powerful alternative for teams who want complete control over their data without sacrificing modern features. In this comprehensive guide, we will explore why Docmost is a game-changer for development teams and provide a step-by-step walkthrough for deploying it on a Virtual Private Server (VPS).

Why Docmost is Ideal for Development Teams

Choosing the right documentation tool can significantly impact your team's velocity. Docmost stands out in the crowded space of wiki software for several compelling reasons:

Blazing Fast Performance: Built on the Go backend and a highly optimized frontend, Docmost boots instantly and operates with a fraction of the RAM required by Java-based or heavy Node.js alternatives.
Real-Time Collaborative Editing: Multiple developers can work on the same document simultaneously, seeing edits in real-time without merge conflicts—crucial for brainstorming sessions and post-mortems.
Developer-Friendly Editor: Supporting rich text, markdown shortcuts, code syntax highlighting, and structured callouts, it feels native to engineers.
Granular Permissions & Spaces: Organize your documentation into distinct "Spaces" (e.g., Frontend, DevOps, Product) and assign role-based access control to keep sensitive infrastructure data secure.
Self-Hosted Data Sovereignty: By deploying Docmost on your own VPS, you ensure compliance with data protection regulations and keep your intellectual property entirely under your control.

Prerequisites for VPS Deployment

Before initiating the installation process, ensure your infrastructure meets the following baseline requirements:

A Linux VPS: A modest server running Ubuntu 22.04 LTS or later. Since Docmost is written in Go, 1 vCPU and 1GB of RAM are sufficient for small to medium-sized teams.
A Fully Qualified Domain Name (FQDN): A domain or subdomain (e.g., wiki.yourcompany.com) pointed to your VPS IP address.
Docker and Docker Compose Installed: The cleanest and most maintainable way to manage the application stack.
Ports Open: Ensure your firewall allows traffic on ports 80 (HTTP) and 443 (HTTPS).

Step-by-Step Guide: Deploying Docmost via Docker Compose

Using Docker Compose simplifies the orchestration of the Docmost application container and its dependent database. Follow these steps to get your environment up and running.

Step 1: System Update and Directory Setup

First, SSH into your VPS and ensure your system packages are up to date. Then, create a dedicated directory for your Docmost deployment to keep your configuration files organized.

sudo apt update && sudo apt upgrade -y
mkdir -p /opt/docmost
cd /opt/docmost

Step 2: Configuring the Environment File

Docmost relies on environment variables to manage database connections, security keys, and site settings. Create a .env file in your directory:

nano .env

Populate the file with the following variables, making sure to replace the placeholder values with secure, randomly generated keys:

# General Settings
APP_ENV=production
APP_URL=[https://wiki.yourcompany.com](https://wiki.yourcompany.com)
PORT=3000

# Database Configuration
DB_DRIVER=postgres
DB_HOST=db
DB_PORT=5432
DB_USER=docmost_user
DB_PASSWORD=YOUR_STRONG_DB_PASSWORD
DB_NAME=docmost_db

# Security Secrets (Generate strong random strings)
APP_SECRET=YOUR_SUPER_SECRET_APP_KEY
JWT_SECRET=YOUR_SUPER_SECRET_JWT_KEY

Security Tip: Never expose your .env file publicly or commit it to version control systems like GitHub. Use a command like openssl rand -hex 32 to generate your cryptographic secrets.

Step 3: Creating the Docker Compose File

Docmost requires a PostgreSQL database to store text content and structural data. We will define both the application service and the database service within a single docker-compose.yml file.

nano docker-compose.yml

Paste the following YAML configuration into the file:

version: '3.8'

services:
  docmost:
    image: docmost/docmost:latest
    container_name: docmost_app
    restart: always
    ports:
      - "3000:3000"
    environment:
      - APP_ENV=${APP_ENV}
      - APP_URL=${APP_URL}
      - PORT=${PORT}
      - DB_DRIVER=${DB_DRIVER}
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_NAME=${DB_NAME}
      - APP_SECRET=${APP_SECRET}
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      - db
    volumes:
      - docmost_data:/app/uploads

  db:
    image: postgres:15-alpine
    container_name: docmost_db
    restart: always
    environment:
      POSTGRES_USER=${DB_USER}
      POSTGRES_PASSWORD=${DB_PASSWORD}
      POSTGRES_DB=${DB_NAME}
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  docmost_data:
  postgres_data:

Step 4: Launching the Containers

With the configurations firmly in place, initialize the stack in detached mode so it runs seamlessly in the background:

docker compose up -d

Verify that both containers are running correctly by checking the process logs:

docker compose ps

Configuring Nginx Reverse Proxy and SSL Certificates

To securely access your documentation portal over HTTPS, setting up a reverse proxy with Nginx and securing it with Let's Encrypt SSL certificates is highly recommended.

Step 1: Install Nginx

sudo apt install nginx -y

Step 2: Create Nginx Server Block

Create a configuration file for your Docmost subdomain:

sudo nano /etc/nginx/sites-available/docmost

Add the following configuration, routing inbound traffic from port 80 to your internal Docker service running on port 3000:

server {
    listen 80;
    server_name wiki.yourcompany.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Enable the site configuration and restart Nginx:

sudo ln -s /etc/nginx/sites-available/docmost /etc/nginx/sites-enabled/
sudo systemctl restart nginx

Step 3: Secure with Let's Encrypt SSL

Install Certbot and its Nginx plugin to automate SSL acquisition and automated renewals:

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d wiki.yourcompany.com

Follow the interactive prompts to complete the SSL configuration. Certbot will automatically rewrite your Nginx file to strictly enforce HTTPS traffic, ensuring all collaborative sessions are encrypted end-to-end.

The Initial Setup Wizard

Open your preferred web browser and navigate to your domain: [https://wiki.yourcompany.com](https://wiki.yourcompany.com). You will be greeted by the Docmost Initial Setup Wizard.

Here, you will register the global administrator account. Fill in your name, professional email address, and a robust password. Once completed, you will be redirected to the main dashboard. From here, you can immediately initiate workspace configuration, create team Spaces, and invite engineers via email to begin real-time documentation sprints.

Conclusion: Empowering Your Development Team

Documentation shouldn't be an afterthought hindered by sluggish software or convoluted pricing tiers. By deploying Docmost on a self-hosted VPS, you deliver a blazing-fast, modern, real-time editing workspace tailored specifically for development teams. The Go backend guarantees that your resources remain unburdened, allowing your infrastructure budget to be allocated where it matters most: powering your applications. Take control of your company's intellectual property today with this elegant, high-performance wiki stack.