Skip to content
Klutch.sh Docs

Deploying a Convos App

Introduction

Convos is a modern chat application built from the ground up to help teams communicate effectively. It brings real-time messaging, team collaboration, and conversation management into a single, elegant platform that works across devices and scales with your team.

What sets Convos apart is its focus on simplicity without sacrificing power. Whether you’re a small team just getting started with internal communication or a larger organization managing multiple channels and thousands of conversations, Convos provides the infrastructure you need without unnecessary complexity.

Core Strengths of Convos:

Intuitive Interface: Clean, modern design that requires zero training. Your team starts chatting immediately without learning a steep interface.

Real-Time Messaging: Messages deliver instantly to all connected users. See who’s typing, reactions to messages, and conversation updates as they happen.

Team Channels: Organize conversations by topic, project, or team. Create public channels everyone can join or private channels for sensitive discussions.

Persistent History: Never lose a message. Full chat history searchable by content, date, or participant. Archive important conversations.

Mobile Ready: Web-based application works perfectly on phones and tablets. No native app installation required—just visit your Convos domain.

Self-Hosted Control: Keep conversations within your infrastructure. Full control over data, compliance, and retention policies.

User Management: Simple user administration. Invite team members, manage roles, and control access to channels.

Integration Ready: Built to integrate with other tools. Webhooks and APIs let you connect Convos to your existing workflow.

Lightweight and Fast: Built with modern technologies that keep the application lean and responsive. Handles thousands of concurrent users.

Convos is perfect for organizations that want reliable team communication without vendor lock-in or monthly per-user fees. Deploy it once on Klutch.sh and it scales with your team.

This guide walks you through deploying Convos on Klutch.sh using Docker. You’ll learn how to set up the application with persistent storage for chat history, configure real-time messaging infrastructure, implement security best practices, optimize performance for concurrent users, and troubleshoot common issues in production environments.

Prerequisites

Before deploying Convos to Klutch.sh, ensure you have:

  • A Klutch.sh account with dashboard access
  • A GitHub account for repository hosting
  • Docker installed locally for testing (optional but recommended)
  • Basic understanding of chat applications and real-time communication
  • Familiarity with HTTP and WebSocket protocols
  • A domain name for your Convos deployment (recommended)
  • Understanding of user authentication and session management

Understanding Convos Architecture

Technology Stack

Convos is built on proven, scalable technologies:

Core Platform:

  • Perl backend with Mojolicious framework
  • Node.js or Perl event loop for real-time communication
  • WebSocket support for instant messaging
  • SQLite or PostgreSQL for data persistence
  • Redis for session management and caching (optional)

Frontend:

  • Modern JavaScript for responsive interface
  • WebSocket client for real-time updates
  • Mobile-optimized responsive design
  • Progressive web app capabilities

Messaging:

  • In-app direct messages between users
  • Channel-based group conversations
  • Message notifications and indicators
  • Thread support for organized discussions

Data Storage:

  • Persistent database for users, channels, and messages
  • Session storage for active connections
  • Optional Redis for distributed caching
  • File upload support for sharing documents

Real-Time Infrastructure:

  • WebSocket connections for instant updates
  • User presence indicators
  • Typing notifications
  • Read receipts and message status

Core Components

Web Server: HTTP and WebSocket server handling API requests and real-time connections

Authentication: User login system with session management

Message Store: Database storing all messages, channels, and user data

Notification System: Real-time updates to connected clients

File Storage: Handling uploaded files and attachments

User Management: Administration interface for managing team members

Channel Management: Creating and managing team spaces

Search: Finding messages and conversations by content

Installation and Setup

Step 1: Create Your Project Directory

Start with a dedicated directory for your Convos deployment:

Terminal window
mkdir convos-deployment
cd convos-deployment
git init

Step 2: Create Directory Structure

Set up the necessary directories for a production-ready deployment:

Terminal window
mkdir -p data logs config

Your project structure will look like:

convos-deployment/
├── Dockerfile
├── docker-entrypoint.sh
├── .env.example
├── .dockerignore
├── .gitignore
├── config/
│   └── (configuration files)
├── data/
│   └── (database and application data)
└── logs/
    └── (application logs)

Step 3: Create the Dockerfile

Create a Dockerfile for a production-ready Convos deployment:

# Use official Convos image as base
FROM convos/convos:latest


# Install additional utilities
RUN apk add --no-cache \
    curl \
    dumb-init \
    postgresql-client


# Create app user
RUN addgroup -g 1000 convos && \
    adduser -D -u 1000 -G convos convos


# Set working directory
WORKDIR /app


# Create necessary directories
RUN mkdir -p /app/data /app/logs /app/config && \
    chown -R convos:convos /app


# Set permissions
RUN chown -R convos:convos /var/cache/convos


# Switch to non-root user
USER convos


# Expose port
EXPOSE 3000


# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
    CMD curl -f http://localhost:3000/ || exit 1


# Use dumb-init to handle signals properly
ENTRYPOINT ["dumb-init", "--"]


# Start Convos
CMD ["convos", "daemon", "-l", "http://*:3000"]

Step 4: Create Environment Configuration

Create .env.example for Convos configuration:

Terminal window
# Server configuration
PORT=3000
LOG_LEVEL=info
NODE_ENV=production


# Application settings
APP_TITLE=Convos Team Chat
APP_DESCRIPTION=Real-time team communication platform
SECRET=your-secret-key-here-change-in-production


# Database configuration
# For SQLite (default)
CONVOS_HOME=/app/data


# For PostgreSQL (optional, uncomment to use)
# DATABASE_URL=postgresql://convos:password@localhost:5432/convos
# CONVOS_DB_URL=postgresql://convos:password@localhost:5432/convos


# Redis configuration (optional)
REDIS_URL=redis://redis:6379/0


# Authentication
CONVOS_SECURITY_DISABLE_FORM_LOGIN=0
CONVOS_SECURE_COOKIES=1


# Email configuration
CONVOS_SMTP_HOST=smtp.example.com
CONVOS_SMTP_PORT=587
CONVOS_SMTP_FROM=noreply@example.com
CONVOS_SMTP_USERNAME=your-email@example.com
CONVOS_SMTP_PASSWORD=your-password


# Message settings
CONVOS_MAX_MESSAGE_SIZE=10000
CONVOS_HISTORY_LIMIT=1000


# File upload settings
CONVOS_MAX_UPLOAD_SIZE=52428800
UPLOAD_DIR=/app/data/uploads


# WebSocket configuration
CONVOS_WEBSOCKET_HEARTBEAT=30


# Additional settings
CONVOS_BACKEND_EVENTS_ENABLED=1

Step 5: Create Application Configuration

Create config/convos.conf for application settings:

# Convos Configuration File


# Basic application settings
app_title = Convos Team Chat
app_description = Real-time team communication platform


# Database settings
# Default SQLite location
convos_home = /app/data


# For PostgreSQL, use database_url instead
# database_url = postgresql://convos:password@localhost:5432/convos


# Server settings
listen = http://*:3000


# Logging
log_level = info


# Authentication
secure_cookies = 1
disable_form_login = 0


# Upload settings
max_upload_size = 52428800
upload_dir = /app/data/uploads


# Message settings
max_message_size = 10000
history_limit = 1000


# WebSocket
websocket_heartbeat = 30


# Email notifications
smtp_host = smtp.example.com
smtp_port = 587
smtp_from = noreply@example.com
smtp_tls = 1


# Features
backend_events_enabled = 1

Step 6: Create Docker Entry Script

Create docker-entrypoint.sh for container initialization:

#!/bin/sh


set -e


# Wait for database if using PostgreSQL
if [ ! -z "$DATABASE_URL" ]; then
    echo "Waiting for database..."
    until pg_isready -h ${DATABASE_URL#postgresql://} -U convos -d convos 2>/dev/null; do
        printf '.'
        sleep 1
    done
    echo "Database ready!"
fi


# Wait for Redis if configured
if [ ! -z "$REDIS_URL" ]; then
    echo "Waiting for Redis..."
    REDIS_HOST=$(echo $REDIS_URL | sed 's/.*@//; s/:.*//;')
    until redis-cli -h $REDIS_HOST ping > /dev/null 2>&1; do
        printf '.'
        sleep 1
    done
    echo "Redis ready!"
fi


# Create necessary directories
mkdir -p /app/data /app/logs /app/config


# Start Convos
exec "$@"

Make it executable:

Terminal window
chmod +x docker-entrypoint.sh

Step 7: Create package.json

Create package.json for dependency management:

{
  "name": "convos-deployment",
  "version": "1.0.0",
  "description": "Convos team chat application deployment on Klutch.sh",
  "main": "index.js",
  "scripts": {
    "start": "convos daemon -l http://*:3000",
    "dev": "convos daemon -l http://*:3000",
    "build": "echo 'Build complete'"
  },
  "keywords": ["chat", "messaging", "team-communication", "convos"],
  "author": "Your Team",
  "license": "MIT",
  "engines": {
    "node": ">=14.0.0"
  }
}

Step 8: Create .dockerignore

Create .dockerignore:

.git
.gitignore
.env
.env.local
.env.*.local
.DS_Store
node_modules
npm-debug.log
yarn-error.log
data/*
logs/*
.vscode
.idea
README.md
docs/
tests/
coverage/
.eslintrc
.github

Step 9: Create .gitignore

Create .gitignore:

# Environment
.env
.env.local
.env.*.local


# Application
node_modules/
package-lock.json
yarn.lock


# Data and logs
data/
logs/
*.log
npm-debug.log*
yarn-error.log*


# Runtime
tmp/
.cache/
*.pid


# IDE
.vscode/
.idea/
*.swp
*.swo


# OS
.DS_Store
Thumbs.db


# Testing
coverage/
.nyc_output

Step 10: Commit to GitHub

Push your Convos configuration to GitHub:

Terminal window
git add Dockerfile docker-entrypoint.sh .env.example config/ package.json .dockerignore .gitignore
git commit -m "Add Convos chat application Docker configuration for Klutch.sh deployment"
git branch -M main
git remote add origin https://github.com/yourusername/convos-deployment.git
git push -u origin main

Deploying to Klutch.sh

Now let’s deploy Convos to Klutch.sh with proper configuration and persistent storage for chat history.

Deployment Steps

  1. Access Klutch.sh Dashboard

    Navigate to klutch.sh/app and sign in with your GitHub account. This is where you’ll manage your Convos deployment.

  2. Create a New Project

    In the Projects section, click “Create Project” and name it something descriptive like “Team Chat Platform” or “Internal Communications”.

  3. Create a New App

    Within your project, click “Create App” to start configuring your Convos deployment.

  4. Connect Your Repository
    • Select GitHub as your Git source
    • Choose the repository where you pushed your Convos Dockerfile
    • Select the branch to deploy (typically main)

    Klutch.sh will automatically detect the Dockerfile in your repository root.

  5. Configure Traffic Settings
    • Traffic Type: Select HTTP (Convos is a web application)
    • Internal Port: Set to 3000 (Convos default port)

    This allows users to access Convos through their browser via HTTPS.

  6. Configure Environment Variables

    Add the following environment variables to configure your Convos instance:

    Server Configuration:

    PORT=3000
    LOG_LEVEL=info
    NODE_ENV=production

    Application Settings:

    APP_TITLE=Your Team Chat
    APP_DESCRIPTION=Internal team communication
    SECRET=generate-a-strong-random-secret-here

    Database Configuration (choose one):

    For SQLite (built-in, no additional setup):

    CONVOS_HOME=/app/data

    For PostgreSQL (if you have a database):

    DATABASE_URL=postgresql://username:password@hostname:5432/convos
    CONVOS_DB_URL=postgresql://username:password@hostname:5432/convos

    Authentication and Security:

    CONVOS_SECURE_COOKIES=1
    CONVOS_SECURITY_DISABLE_FORM_LOGIN=0

    Email Configuration (for notifications):

    CONVOS_SMTP_HOST=smtp.gmail.com
    CONVOS_SMTP_PORT=587
    CONVOS_SMTP_FROM=noreply@example.com
    CONVOS_SMTP_USERNAME=your-email@gmail.com
    CONVOS_SMTP_PASSWORD=your-app-password

    Message and Upload Settings:

    CONVOS_MAX_MESSAGE_SIZE=10000
    CONVOS_HISTORY_LIMIT=1000
    CONVOS_MAX_UPLOAD_SIZE=52428800
    UPLOAD_DIR=/app/data/uploads

    Optional: Redis for Caching (improves performance):

    REDIS_URL=redis://your-redis-server:6379/0

    Security Notes:

    • Generate a strong SECRET using a random string generator
    • Use HTTPS-only cookies in production (SECURE_COOKIES=1)
    • Rotate API keys and secrets regularly
    • Restrict file upload size based on infrastructure
    • Monitor email quota if using SMTP notifications
  7. Configure Persistent Storage

    Convos needs persistent storage to maintain chat history, user data, and uploaded files:

    Volume 1 - Application Data:

    • Mount Path: /app/data
    • Size: 10-50 GB (depends on expected users and message volume)

    Guidelines for volume sizes:

    • Small team (< 50 users, < 100K messages): 10 GB
    • Medium team (50-200 users, 100K-1M messages): 25 GB
    • Large team (200-1000 users, 1M+ messages): 50+ GB

    Data stored:

    • SQLite database (if not using PostgreSQL)
    • User accounts and authentication
    • Channel definitions and settings
    • All messages and chat history
    • Uploaded files and attachments
    • Session data

    Critical: Without persistent storage, all chat history and user data is lost on container restart. This is essential for any production deployment.

  8. Configure Compute Resources

    Choose appropriate resources based on expected team size and usage:

    Small Team (< 50 users):

    • CPU: 1 core
    • RAM: 1 GB
    • Suitable for: Small teams, internal projects

    Medium Team (50-500 users):

    • CPU: 2 cores
    • RAM: 2 GB
    • Suitable for: Growing teams, moderate message volume

    Large Team (500-2000 users):

    • CPU: 4 cores
    • RAM: 4 GB
    • Suitable for: Enterprise deployments, high-volume communication

    Very Large Team (2000+ users):

    • CPU: 8+ cores
    • RAM: 8+ GB
    • Suitable for: Large organizations, heavy concurrent usage

    Note: Real-time messaging is CPU-bound. More cores handle more concurrent WebSocket connections. Monitor metrics and scale accordingly.

  9. Deploy the Application

    Click “Create” to start the deployment. Klutch.sh will:

    1. Clone your repository from GitHub
    2. Build the Docker image with Convos and dependencies
    3. Configure all environment variables
    4. Set up persistent storage volumes
    5. Start the Convos application
    6. Assign a public URL (e.g., chat.klutch.sh)
    7. Configure automatic HTTPS with SSL certificates

    Initial deployment typically takes 5-10 minutes. The application will be ready once the status shows “Running”.

  10. Monitor Deployment Progress

    Track your deployment:

    • Go to the Deployments tab
    • View real-time build logs
    • Wait for status to show “Running”
    • Verify environment variables are correctly set
    • Check that persistent storage is mounted

    Ensure the Convos service starts without errors.

  11. Test Your Deployment

    After deployment, verify Convos is working:

    1. Access the Application: Open your browser and navigate to your deployment URL (e.g., https://example-app.klutch.sh)

    2. Create Admin User:

      • First access opens admin user creation page
      • Create your admin account
      • Set a strong password

    3. Access Dashboard:

      • Log in with admin account
      • You’re now in the Convos dashboard
      • Create channels and add users

    4. Test Real-Time Messaging:

      • Open multiple browser windows
      • Send messages in a channel
      • Verify messages appear instantly across windows
      • Test typing indicators

    5. Check Logs:

      • View application logs in Klutch.sh dashboard
      • Look for any warnings or errors
      • Verify WebSocket connections are established
  12. Configure Your Domain

    Add your custom domain for professional chat access:

    1. In Klutch.sh dashboard, go to Domains
    2. Click “Add Custom Domain”
    3. Enter your domain (e.g., chat.example.com)
    4. Update DNS with CNAME record pointing to example-app.klutch.sh
    5. Wait for DNS propagation and SSL certificate provisioning

    Update Convos Configuration:

    1. Add domain to environment variables if needed
    2. Update any webhook URLs or integrations
    3. Test access from your custom domain
  13. Complete Initial Setup

    After first deployment, complete these setup steps:

    1. Create Channels:

      • General for team-wide discussions
      • Project-specific channels
      • Department or skill-based channels
      • Social or off-topic channel

    2. Invite Team Members:

      • Go to Settings → Users
      • Invite team members via email
      • Set appropriate roles and permissions

    3. Configure Notifications:

      • Set up email notifications
      • Configure notification preferences
      • Test notification delivery

    4. Set Up Integrations (if needed):

      • Connect external tools via webhooks
      • Configure API access for applications

    5. Establish Guidelines:

      • Create pinned messages with team guidelines
      • Document channel purposes
      • Share security best practices

Getting Started with Convos

Creating Your First Channels

After deploying Convos, create channels for different teams or topics:

General
├── Announcements
├── Random
└── Help


Engineering
├── Backend
├── Frontend
├── DevOps
└── QA


Projects
├── Project Alpha
├── Project Beta
└── Project Gamma

User Management

Add team members through the admin interface:

  1. Navigate to Settings → Users
  2. Click “Add User”
  3. Enter email address
  4. Select user role (Member or Admin)
  5. Send invitation

Users receive email invitations with signup links.

Integration Examples

Connect Convos with external tools:

GitHub Integration:

Create a webhook in GitHub repository:
Payload URL: https://chat.example.com/api/hooks/github
Content type: application/json
Events: Issues, Pull Requests, Pushes

Custom Webhooks:

// Send message to Convos channel
const axios = require('axios');


axios.post('https://chat.example.com/api/messages', {
  channel: 'general',
  message: 'Build completed successfully',
  from: 'CI System'
});

Performance Optimization

Connection Management

Optimize Convos for concurrent users:

# Increase connection limits
CONVOS_WEBSOCKET_HEARTBEAT=30


# Message queue settings
CONVOS_BACKEND_EVENTS_ENABLED=1

Database Optimization

For SQLite (built-in):

  • Regular database maintenance
  • Archive old messages periodically
  • Monitor database file size

For PostgreSQL (larger deployments):

  • Better concurrency handling
  • Easier backup and recovery
  • Horizontal scaling options

Caching Strategy

Use Redis for improved performance:

REDIS_URL=redis://hostname:6379/0

Caches:

  • Session data
  • Frequently accessed channels
  • User presence information
  • Message metadata

Memory Management

Monitor and optimize memory usage:

# Limit history returned per request
CONVOS_HISTORY_LIMIT=1000


# Monitor WebSocket connections
Connection pooling: Enabled by default

Security Best Practices

Authentication

User Access:

  • Enforce strong passwords
  • Implement account lockout after failed attempts
  • Regularly audit user access

Admin Protection:

  • Limit admin user count
  • Use separate admin account for administration
  • Rotate admin credentials regularly

Data Security

Message Encryption:

  • All connections use HTTPS/WSS
  • Messages in transit are encrypted
  • Consider message encryption at rest

User Privacy:

  • Clear privacy policies
  • Regular security audits
  • Compliance with regulations (GDPR, etc.)

Access Control

Channel Permissions:

  • Public channels: Team can view and join
  • Private channels: Invite-only access
  • Archived channels: Read-only history

File Security:

  • Restrict upload types (prevent executable files)
  • Limit file sizes
  • Regular virus scanning

Regular Maintenance

Update Schedule:

  • Monitor Convos releases for security patches
  • Test updates in staging environment
  • Deploy to production with clear communication

Audit Logs:

  • Enable audit logging for admin actions
  • Monitor user login patterns
  • Review file access and downloads

Troubleshooting

Issue 1: Users Unable to Connect

Symptoms: Browser shows connection error, WebSocket fails

Solutions:

  1. Check Application Status:

    • Verify app is running in Klutch.sh dashboard
    • Check deployment logs for startup errors
    • Confirm health check is passing

  2. Verify Network Settings:

    • Ensure HTTP/HTTPS traffic is allowed
    • Check firewall rules are not blocking connections
    • Verify domain DNS is resolving correctly

  3. Test Connectivity:

    Terminal window
    # Test basic HTTP access
    curl -I https://example-app.klutch.sh
    

    # Check WebSocket connectivity
    wscat -c wss://example-app.klutch.sh/ws

  4. Browser Issues:

    • Clear browser cache and cookies
    • Try different browser to isolate issues
    • Check browser console for JavaScript errors

Issue 2: Message History Not Persistent

Symptoms: Messages disappear after restart, chat history lost

Solutions:

  1. Verify Persistent Volume:

    • Confirm volume is mounted at /app/data
    • Check volume has sufficient space
    • Verify mount path in deployment settings

  2. Check Database:

    • Confirm SQLite file exists in /app/data
    • For PostgreSQL, verify connection string is correct
    • Test database connectivity

  3. Review Logs:

    • Check for database errors in application logs
    • Look for permission issues on data directory
    • Verify SQLite database isn’t corrupted

  4. Restore from Backup:

    • If using PostgreSQL, restore from backup
    • For SQLite, restore database file from backup
    • Test message retrieval after restore

Issue 3: Slow Message Delivery

Symptoms: Messages take seconds to appear, lag between users

Solutions:

  1. Check Resource Usage:

    • Monitor CPU utilization during peak usage
    • Check memory consumption
    • Review network latency

  2. Optimize Database:

    • For SQLite, reduce history limit
    • Archive old messages to separate storage
    • Consider PostgreSQL for better performance

  3. Enable Caching:

    • Configure Redis for session caching
    • Cache frequently accessed channels
    • Reduce database queries

  4. Monitor Connections:

    • Check number of concurrent WebSocket connections
    • Upgrade resources if near capacity
    • Review slow query logs

Issue 4: High Memory Usage

Symptoms: Application becomes sluggish, memory warnings

Solutions:

  1. Increase Compute Resources:

    • Upgrade Klutch.sh allocation
    • Add more RAM for large deployments
    • Monitor metrics to determine optimal size

  2. Optimize Settings:

    • Reduce message history limit
    • Enable connection pooling
    • Configure garbage collection tuning

  3. Profile Memory Usage:

    • Monitor connection count
    • Track message queue depth
    • Review cache hit rates

Issue 5: File Upload Issues

Symptoms: Upload fails, files not saved, storage errors

Solutions:

  1. Check Storage:

    • Verify upload directory has sufficient space
    • Confirm /app/data/uploads directory exists
    • Check file permissions

  2. Verify Settings:

    • Check CONVOS_MAX_UPLOAD_SIZE is appropriate
    • Confirm UPLOAD_DIR points to persistent volume
    • Review upload file type restrictions

  3. Monitor Space:

    • Track persistent volume usage
    • Implement automatic cleanup of old files
    • Archive or compress large uploads

Issue 6: Email Notifications Not Working

Symptoms: Users don’t receive invitation or notification emails

Solutions:

  1. Verify SMTP Settings:

    • Check CONVOS_SMTP_HOST is correct
    • Verify port (CONVOS_SMTP_PORT) is 587 or 465
    • Confirm username and password are correct

  2. Test Email:

    Terminal window
    # Test SMTP connectivity
    telnet smtp.example.com 587

  3. Check Logs:

    • Review email sending logs
    • Look for SMTP error messages
    • Verify sender address is authorized

  4. Provider Issues:

    • Gmail requires app passwords, not regular password
    • Check if SMTP provider allows external connections
    • Verify sender email is whitelisted

Custom Domain Setup

Using a custom domain makes Convos feel like a core part of your infrastructure.

Step 1: Add Domain in Klutch.sh

  1. Go to your Convos app in Klutch.sh dashboard
  2. Navigate to Domains
  3. Click “Add Custom Domain”
  4. Enter your domain (e.g., chat.example.com)
  5. Save

Step 2: Update DNS

Update your domain provider’s DNS records:

Type: CNAME
Name: chat
Value: example-app.klutch.sh
TTL: 3600

Step 3: Verify SSL Certificate

Klutch.sh automatically provisions SSL certificates:

  1. Wait for DNS propagation (up to 1 hour)

  2. Test HTTPS access:

    Terminal window
    curl -I https://chat.example.com

  3. Certificate is automatically renewed (no action needed)

Step 4: Update Convos Configuration

Update any application settings that reference your domain:

  1. Email addresses in notifications
  2. Webhook URLs in integrations
  3. Any hardcoded domain references

Production Best Practices

Backup Strategy

What to Back Up:

  1. SQLite database file (/app/data/convos.db)
  2. Uploaded files (/app/data/uploads)
  3. Application configuration

For PostgreSQL:

Terminal window
pg_dump postgresql://username:password@host/convos | gzip > /backup/convos-$(date +%Y%m%d).sql.gz

For SQLite:

Terminal window
tar -czf /backup/convos-data-$(date +%Y%m%d).tar.gz /app/data

Backup Schedule:

  • Daily: Automated backups
  • Weekly: Full backup verification
  • Monthly: Restore test from backup

Backup Location:

  • Store off-server (cloud storage, NAS)
  • Encrypted backups for security
  • Document recovery procedures

Monitoring Strategy

Key Metrics:

  • Number of active connections
  • Average response time
  • CPU and memory usage
  • Persistent volume utilization
  • Message throughput
  • Error rates

Alerts:

  • Alert if CPU > 80% sustained
  • Alert if memory > 90% capacity
  • Alert if volume nearing full
  • Alert if response time > 2 seconds
  • Alert if error rate > 1%

Tools:

  • Klutch.sh dashboard metrics
  • Prometheus for detailed monitoring
  • Grafana for visualization

Scaling Strategy

Vertical Scaling (larger server):

  • Increase CPU cores for more concurrent connections
  • Add RAM for larger caches and buffers
  • Use faster storage for better I/O

Horizontal Scaling (multiple servers):

  • Run multiple Convos instances behind load balancer
  • Use PostgreSQL for shared database
  • Use Redis for shared session store
  • Use object storage for file uploads

When to Scale:

  • CPU consistently > 70%
  • Memory consistently > 80%
  • Response times degrading during peak hours
  • Connection limit being approached

User Administration

Regular Tasks:

  • Review active users monthly
  • Archive inactive accounts
  • Update permission levels as needed
  • Remove terminated user accounts

Access Review:

  • Quarterly audit of admin users
  • Review channel access for sensitive teams
  • Verify no user has elevated access without reason

Conclusion

You now have a production-ready Convos deployment running on Klutch.sh. Your team has a reliable, self-hosted chat platform for real-time collaboration and communication.

Convos brings the simplicity of modern chat with the control of self-hosting. Your messages, your data, your infrastructure—no monthly fees per user, no vendor lock-in, just solid team communication.

The deployment you’ve built handles the complexity of real-time messaging, persistent storage, and concurrent user management. Scale it up as your team grows, backup your data regularly, and monitor performance to keep everything running smoothly.

Whether it’s a small team getting started with internal communication or a larger organization managing complex team dynamics, Convos provides the foundation for effective collaboration. Focus on building great products while Convos keeps your team connected.

For additional help, check out the Convos documentation, explore advanced configuration options, and join the community for support and ideas.

Happy chatting!