Skip to content
Klutch.sh Docs

Deploying Coral

Introduction

Coral is a community engagement platform built for publishers, news organizations, and online communities who want to foster thoughtful discussions while maintaining healthy moderation standards. It brings powerful community management tools together with user-friendly discussion features that encourage quality conversations.

Coral transforms how organizations approach community engagement. Instead of defaulting to closed comment systems or chaotic unmoderated discussions, Coral provides the infrastructure for building engaged, civil communities where meaningful conversations thrive while bad actors are effectively managed.

Core Strengths of Coral:

Real-Time Discussions: Engage readers with live comment threads on articles and stories. Users see discussions as they unfold with real-time updates and notifications.

Intelligent Moderation: Powerful moderation tools help teams maintain community standards. Flag inappropriate content, temporarily suspend users, or permanently ban disruptive members. Bulk actions save time managing large communities.

Story Integration: Embed comments directly in your articles and stories. Coral integrates with your existing CMS or custom content systems via API.

Audience Insights: Understand your community with detailed analytics. See which stories spark the most discussion, who your most active members are, and what topics drive engagement.

Customizable Community Rules: Set community guidelines and automatically enforce them. Configure content filters, moderation workflows, and escalation rules that match your publication’s values.

User Authentication: Integrate with your existing authentication systems or use Coral’s built-in user management. Require email verification, moderate new users, or restrict access to subscribers.

Reputation System: Build community trust through reputation badges, user trust levels, and comment ratings. Encourage quality contributions and recognize valued community members.

Performance at Scale: Built to handle millions of comments and thousands of concurrent users. Real-time performance doesn’t degrade as your community grows.

API-Driven Architecture: Integrate Coral into any content system. Flexible APIs let you customize the experience for your specific needs.

Privacy Focused: User data stays in your infrastructure. Full control over data retention, compliance, and user privacy policies.

Whether you’re a news organization building reader engagement, a SaaS company fostering user communities, or a publisher seeking healthier discussions, Coral provides the platform to build thriving communities.

This guide walks you through deploying Coral on Klutch.sh. You’ll learn how to set up the community platform with persistent storage for discussions and user data, configure moderation infrastructure, implement content policies, optimize performance for your audience size, and troubleshoot common issues in production.

Prerequisites

Before deploying Coral 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)
  • Understanding of community moderation principles
  • Basic knowledge of content management systems
  • Familiarity with user authentication and permissions
  • A domain name for your Coral instance (recommended)
  • Understanding of real-time web technologies

Understanding Coral Architecture

Technology Stack

Coral is built on modern, scalable technologies:

Core Platform:

  • Node.js with TypeScript for type-safe backend
  • GraphQL API for flexible data querying
  • React frontend for responsive interface
  • MongoDB for flexible document storage
  • Redis for real-time features and caching

Real-Time Infrastructure:

  • WebSocket connections for live updates
  • Server-sent events for notifications
  • Real-time comment streams
  • Live moderation queue updates

Discussion Features:

  • Comment threads and nested replies
  • Comment ratings and reactions
  • User mentions and notifications
  • Spam and toxicity detection

Moderation System:

  • Comment flags and reports
  • Automated content filtering
  • Moderator queues and workflows
  • User suspension and banning
  • Comment editing and removal

Authentication and Identity:

  • OAuth 2.0 integration
  • Email verification
  • Single sign-on support
  • Custom identity providers

Analytics and Reporting:

  • Community health metrics
  • Discussion analytics
  • Moderation reporting
  • User engagement tracking

Core Components

API Server: GraphQL API handling all community operations

Real-Time Engine: WebSocket server for live updates

Comment Store: MongoDB collection for all discussions

User System: Authentication, profiles, and permissions

Moderation Engine: Comment flags, queues, and workflows

Notification System: Real-time alerts and digests

Search: Indexing and searching discussions

Cache Layer: Redis for performance optimization

Installation and Setup

Step 1: Create Your Project Directory

Start with a dedicated directory for your Coral deployment:

Terminal window
mkdir coral-deployment
cd coral-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:

coral-deployment/
├── Dockerfile
├── docker-compose.yml
├── docker-entrypoint.sh
├── .env.example
├── .dockerignore
├── .gitignore
├── config/
│   └── coral-config.js
└── logs/
    └── (application logs)

Step 3: Create the Dockerfile

Create a Dockerfile for a production-ready Coral deployment:

# Build stage
FROM node:18-alpine as builder


WORKDIR /build


# Install build dependencies
RUN apk add --no-cache \
    python3 \
    make \
    g++ \
    curl


# Clone or copy Coral source
# Option 1: Clone from repository
RUN git clone https://github.com/coralproject/talk.git . || true


# Install dependencies
RUN npm ci


# Build Coral
RUN npm run build


# Runtime stage
FROM node:18-alpine


# Install runtime dependencies
RUN apk add --no-cache \
    ca-certificates \
    curl \
    dumb-init


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


WORKDIR /app


# Copy built application from builder
COPY --from=builder --chown=coral:coral /build/dist ./dist
COPY --from=builder --chown=coral:coral /build/node_modules ./node_modules
COPY --from=builder --chown=coral:coral /build/package*.json ./


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


# Copy configuration
COPY --chown=coral:coral config/ ./config/


# Switch to non-root user
USER coral


# Expose port
EXPOSE 5000


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


# Use dumb-init for proper signal handling
ENTRYPOINT ["dumb-init", "--"]


# Start Coral
CMD ["node", "dist/server.js"]

Step 4: Create Environment Configuration

Create .env.example for Coral configuration:

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


# Application settings
APP_NAME=Coral Community Platform
APP_URL=https://example-app.klutch.sh
TIMEZONE=UTC


# MongoDB configuration
MONGODB_URI=mongodb://coral:password@localhost:27017/coral?authSource=admin
MONGODB_POOL_SIZE=50


# Redis configuration (required)
REDIS_URI=redis://localhost:6379/0
REDIS_PASSWORD=


# JWT configuration
JWT_SECRET=your-secret-key-change-this
JWT_EXPIRY=7d
JWT_ALGORITHM=HS256


# Authentication
AUTH_ENABLED=true
ALLOW_REGISTRATION=true
EMAIL_VERIFICATION_REQUIRED=true


# Email configuration
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_FROM=noreply@example.com
SMTP_USERNAME=your-email@example.com
SMTP_PASSWORD=your-password
SMTP_TLS=true


# Moderation settings
MODERATION_ENABLED=true
AUTO_FLAG_ENABLED=false
COMMENT_QUEUE_ENABLED=true
USER_SUSPENSION_ENABLED=true


# Comment settings
MAX_COMMENT_LENGTH=5000
MAX_REPLIES=1000
ALLOW_ANONYMOUS_COMMENTS=false
COMMENT_RATE_LIMIT=10


# Story and Integration settings
ALLOW_STORIES=true
ALLOW_CUSTOM_CSS=true
WEBHOOK_ENABLED=true


# Analytics
ANALYTICS_ENABLED=true
TRACK_PAGEVIEWS=true


# Security
CORS_ENABLED=true
CORS_ORIGINS=https://example.com
HELMET_ENABLED=true
RATE_LIMIT=100


# Optional: OAuth providers
GOOGLE_OAUTH_ENABLED=false
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=


FACEBOOK_OAUTH_ENABLED=false
FACEBOOK_APP_ID=
FACEBOOK_APP_SECRET=


# Backup settings
BACKUP_ENABLED=true
BACKUP_SCHEDULE=daily
BACKUP_RETENTION_DAYS=30

Step 5: Create Application Configuration

Create config/coral-config.js:

module.exports = {
  // Server configuration
  server: {
    port: process.env.PORT || 5000,
    nodeEnv: process.env.NODE_ENV || 'production',
    logLevel: process.env.LOG_LEVEL || 'info',
    timezone: process.env.TIMEZONE || 'UTC',
  },


  // Database configuration
  mongo: {
    uri: process.env.MONGODB_URI,
    poolSize: parseInt(process.env.MONGODB_POOL_SIZE) || 50,
  },


  // Redis configuration
  redis: {
    uri: process.env.REDIS_URI,
    password: process.env.REDIS_PASSWORD,
  },


  // Authentication
  auth: {
    enabled: process.env.AUTH_ENABLED === 'true',
    allowRegistration: process.env.ALLOW_REGISTRATION === 'true',
    emailVerificationRequired: process.env.EMAIL_VERIFICATION_REQUIRED === 'true',
    jwtSecret: process.env.JWT_SECRET,
    jwtExpiry: process.env.JWT_EXPIRY || '7d',
  },


  // Email configuration
  email: {
    host: process.env.SMTP_HOST,
    port: parseInt(process.env.SMTP_PORT) || 587,
    from: process.env.SMTP_FROM,
    username: process.env.SMTP_USERNAME,
    password: process.env.SMTP_PASSWORD,
    tls: process.env.SMTP_TLS === 'true',
  },


  // Moderation
  moderation: {
    enabled: process.env.MODERATION_ENABLED === 'true',
    autoFlagEnabled: process.env.AUTO_FLAG_ENABLED === 'true',
    commentQueueEnabled: process.env.COMMENT_QUEUE_ENABLED === 'true',
    userSuspensionEnabled: process.env.USER_SUSPENSION_ENABLED === 'true',
  },


  // Comments
  comments: {
    maxLength: parseInt(process.env.MAX_COMMENT_LENGTH) || 5000,
    maxReplies: parseInt(process.env.MAX_REPLIES) || 1000,
    allowAnonymous: process.env.ALLOW_ANONYMOUS_COMMENTS === 'true',
    rateLimit: parseInt(process.env.COMMENT_RATE_LIMIT) || 10,
  },


  // Stories
  stories: {
    allowStories: process.env.ALLOW_STORIES === 'true',
    allowCustomCSS: process.env.ALLOW_CUSTOM_CSS === 'true',
    webhookEnabled: process.env.WEBHOOK_ENABLED === 'true',
  },


  // Analytics
  analytics: {
    enabled: process.env.ANALYTICS_ENABLED === 'true',
    trackPageviews: process.env.TRACK_PAGEVIEWS === 'true',
  },


  // Security
  security: {
    corsEnabled: process.env.CORS_ENABLED === 'true',
    corsOrigins: process.env.CORS_ORIGINS?.split(',') || ['*'],
    helmetEnabled: process.env.HELMET_ENABLED === 'true',
    rateLimit: parseInt(process.env.RATE_LIMIT) || 100,
  },
};

Step 6: Create Docker Entry Script

Create docker-entrypoint.sh for container initialization:

#!/bin/sh


set -e


# Wait for MongoDB if configured
if [ ! -z "$MONGODB_URI" ]; then
    echo "Waiting for MongoDB..."
    until mongosh --eval "db.adminCommand('ping')" "$MONGODB_URI" &>/dev/null; do
        printf '.'
        sleep 1
    done
    echo "MongoDB ready!"
fi


# Wait for Redis if configured
if [ ! -z "$REDIS_URI" ]; then
    echo "Waiting for Redis..."
    until redis-cli -u "$REDIS_URI" ping > /dev/null 2>&1; do
        printf '.'
        sleep 1
    done
    echo "Redis ready!"
fi


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


# Run migrations if needed
if [ "$RUN_MIGRATIONS" = "true" ]; then
    echo "Running database migrations..."
    npm run migrate
fi


# Start Coral
echo "Starting Coral..."
exec "$@"

Make it executable:

Terminal window
chmod +x docker-entrypoint.sh

Step 7: Create package.json

Create package.json for deployment:

{
  "name": "coral-deployment",
  "version": "1.0.0",
  "description": "Coral community engagement platform deployment",
  "main": "dist/server.js",
  "scripts": {
    "start": "node dist/server.js",
    "dev": "ts-node src/server.ts",
    "build": "tsc",
    "migrate": "npm run build && node dist/migrate.js"
  },
  "keywords": ["coral", "community", "moderation", "engagement"],
  "author": "Your Team",
  "license": "Apache-2.0",
  "engines": {
    "node": ">=16.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
logs/*
data/*
.vscode
.idea
README.md
docs/
tests/
coverage/
.eslintrc
.github

Step 9: Create .gitignore

Create .gitignore:

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


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


# Logs
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 Coral configuration to GitHub:

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

Deploying to Klutch.sh

Now let’s deploy Coral to Klutch.sh with proper configuration and persistent storage for discussions and community data.

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 Coral deployment.

  2. Create a New Project

    In the Projects section, click “Create Project” and name it something like “Community Platform” or “Discussion Engine”.

  3. Create a New App

    Within your project, click “Create App” to begin configuring your Coral deployment.

  4. Connect Your Repository
    • Select GitHub as your Git source
    • Choose the repository where you pushed your Coral 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 (Coral is a web application)
    • Internal Port: Set to 5000 (Coral default port)

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

  6. Configure Environment Variables

    Add the following environment variables to configure your Coral instance:

    Server Configuration:

    NODE_ENV=production
    PORT=5000
    LOG_LEVEL=info
    APP_NAME=Community Discussions
    APP_URL=https://example-app.klutch.sh
    TIMEZONE=UTC

    Database Configuration:

    For MongoDB (recommended):

    MONGODB_URI=mongodb+srv://user:password@cluster.mongodb.net/coral
    MONGODB_POOL_SIZE=50

    For local MongoDB:

    MONGODB_URI=mongodb://coral:password@localhost:27017/coral?authSource=admin
    MONGODB_POOL_SIZE=50

    Redis Configuration (required):

    REDIS_URI=redis://hostname:6379/0
    REDIS_PASSWORD=your-password

    Authentication and Security:

    JWT_SECRET=generate-a-strong-random-secret-here
    JWT_EXPIRY=7d
    AUTH_ENABLED=true
    ALLOW_REGISTRATION=true
    EMAIL_VERIFICATION_REQUIRED=true

    Email Configuration (for notifications and verification):

    SMTP_HOST=smtp.gmail.com
    SMTP_PORT=587
    SMTP_FROM=noreply@example.com
    SMTP_USERNAME=your-email@gmail.com
    SMTP_PASSWORD=your-app-password
    SMTP_TLS=true

    Moderation Configuration:

    MODERATION_ENABLED=true
    COMMENT_QUEUE_ENABLED=true
    USER_SUSPENSION_ENABLED=true
    AUTO_FLAG_ENABLED=false

    Comment Settings:

    MAX_COMMENT_LENGTH=5000
    MAX_REPLIES=1000
    ALLOW_ANONYMOUS_COMMENTS=false
    COMMENT_RATE_LIMIT=10

    CORS and Security:

    CORS_ENABLED=true
    CORS_ORIGINS=https://your-domain.com
    HELMET_ENABLED=true
    RATE_LIMIT=100

    Optional: OAuth Integration:

    GOOGLE_OAUTH_ENABLED=false
    FACEBOOK_OAUTH_ENABLED=false

    Security Notes:

    • Generate a strong JWT_SECRET using a cryptographic generator
    • Use app-specific passwords for Gmail/email providers
    • Keep MONGODB_URI and REDIS_URI secure
    • Restrict CORS_ORIGINS to your domains only
    • Adjust rate limits based on expected traffic
  7. Configure Persistent Storage

    Coral needs persistent storage to maintain all community discussions and user data:

    Volume 1 - Application Data:

    • Mount Path: /app/data
    • Size: 20-100 GB (depends on comment volume and archive size)

    Guidelines for volume sizes:

    • Small community (< 10K comments): 20 GB
    • Medium community (10K-100K comments): 50 GB
    • Large community (100K-1M comments): 100+ GB

    Note: MongoDB data storage requirements:

    • Smaller communities typically use MongoDB Atlas or managed MongoDB
    • For local storage, calculate based on: comments * avg comment size (500 bytes) + indexes (30%)

    Data stored:

    • All comments and discussions
    • User profiles and authentication
    • Moderation logs and flags
    • Reputation and user history
    • Story/article integration data

    Critical: Without persistent storage, all community discussions and user data is lost on container restart.

  8. Configure Compute Resources

    Choose appropriate resources based on expected community size:

    Small Community (< 100 active users):

    • CPU: 1 core
    • RAM: 2 GB
    • Suitable for: Niche communities, internal discussions

    Medium Community (100-1000 active users):

    • CPU: 2 cores
    • RAM: 4 GB
    • Suitable for: Growing publications, mid-size organizations

    Large Community (1000-10000 active users):

    • CPU: 4 cores
    • RAM: 8 GB
    • Suitable for: Popular publications, large platforms

    Very Large Community (10000+ active users):

    • CPU: 8+ cores
    • RAM: 16+ GB
    • Suitable for: Major news outlets, enterprise platforms

    Note: Real-time features are CPU-bound. More cores handle more concurrent WebSocket connections. Monitor actual 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 Coral
    3. Configure all environment variables
    4. Set up persistent storage volumes
    5. Start the Coral server
    6. Assign a public URL (e.g., coral.klutch.sh)
    7. Configure automatic HTTPS with SSL certificates

    Initial deployment typically takes 10-15 minutes.

  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 Coral service starts without errors.

  11. Test Your Deployment

    After deployment, verify Coral is working:

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

    2. Create Admin Account:

      • Set up initial admin user
      • Create a strong password
      • Configure basic settings

    3. Configure Stories:

      • Add a test story/article
      • Set up comment embedding

    4. Test Comments:

      • Create a test comment on your story
      • Verify it appears in real-time
      • Test moderation tools

    5. Check Logs:

      • View application logs in Klutch.sh dashboard
      • Look for any warnings or errors
      • Verify database and Redis connections

    6. Health Check:

      Terminal window
      curl https://example-app.klutch.sh/api/health
  12. Configure Your Domain

    Add a custom domain for your community:

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

    Update Coral Configuration:

    1. Update APP_URL environment variable
    2. Update CORS_ORIGINS if needed
    3. Update website integrations with new domain
    4. Test access from custom domain
  13. Complete Initial Setup**

    After first deployment, complete these setup steps:

    1. Configure Moderation Team:

      • Create moderator accounts
      • Set permission levels
      • Configure moderation queues

    2. Set Community Guidelines:

      • Define flagging reasons
      • Create content policies
      • Set suspension/ban rules

    3. Add Stories:

      • Create initial test stories
      • Embed comment sections
      • Configure comment settings per story

    4. Invite Users:

      • Send invitations or enable registration
      • Configure email verification
      • Set up user onboarding

    5. Configure Analytics:

      • Enable activity tracking
      • Set up moderation reports
      • Configure health dashboards

Getting Started with Coral API

Authentication

Get an API token for integration:

Terminal window
curl -X POST https://example-app.klutch.sh/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "email": "admin@example.com",
    "password": "your-password"
  }'

Comment Embedding

Embed comments in your website:

<div id="coral_thread"></div>
<script src="https://example-app.klutch.sh/embed.js"></script>
<script>
  Coral.embed({
    rootId: "coral_thread",
    storyId: "article-123",
    storyUrl: "https://yoursite.com/article-123"
  });
</script>

Create a Story via API

Terminal window
curl -X POST https://example-app.klutch.sh/graphql \
  -H "Authorization: Bearer TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "mutation { createStory(input: {title: \"Article Title\", url: \"https://example.com/article\"}) { id } }"
  }'

Moderate Comments

Terminal window
curl -X POST https://example-app.klutch.sh/graphql \
  -H "Authorization: Bearer TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "mutation { flagComment(id: \"comment-123\", reason: \"OFFENSIVE\") { id } }"
  }'

Performance Optimization

Real-Time Performance

Optimize WebSocket connections for live updates:

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

Redis manages:

  • WebSocket session data
  • Real-time comment streams
  • Live moderation queue updates
  • Notification delivery

Database Optimization

MongoDB Indexes:

  • Index on story ID for comment queries
  • Index on user ID for user comments
  • Index on created date for sorting
  • Index on flags for moderation queue

Connection Pooling:

MONGODB_POOL_SIZE=50

Caching Strategy

Cache frequently accessed data:

  • Story metadata
  • User profiles
  • Comment counts
  • Moderation statistics

Rate Limiting

Prevent abuse with intelligent rate limiting:

COMMENT_RATE_LIMIT=10

Limits per user per timeframe.

Security Best Practices

Authentication and Access

User Security:

  • Enforce strong passwords (minimum 12 characters)
  • Implement email verification
  • Require password reset on suspicious activity

Moderator Access:

  • Use strong credentials for moderation accounts
  • Limit moderator permissions to necessary actions
  • Regular audits of moderator activity

API Security:

  • Rotate API tokens regularly
  • Use OAuth for third-party integrations
  • Implement rate limiting per API key

Content Moderation

Automated Tools:

  • Configure content filtering
  • Set up toxicity detection
  • Use keyword-based flagging

Manual Review:

  • Maintain moderation queues
  • Regular review of flagged content
  • Escalation procedures for serious violations

User Privacy

Data Protection:

  • Encrypt sensitive user data
  • Implement data deletion for user accounts
  • GDPR-compliant data handling

Comment Privacy:

  • Allow users to delete their comments
  • Implement comment edit history
  • Privacy options per comment

Regular Updates

Keep Coral and dependencies current:

  1. Monitor Coral releases for security updates
  2. Test updates in staging environment
  3. Deploy updates with clear communication
  4. Monitor logs for any issues post-update

Troubleshooting

Issue 1: Users Cannot See Comments

Symptoms: Comment section appears empty, no discussions visible

Solutions:

  1. Verify Story Setup:

    • Confirm story is created in Coral
    • Check story URL is correct
    • Verify story is published

  2. Check Embed Code:

    • Verify embed script URL is correct
    • Confirm storyId and storyUrl parameters match
    • Check browser console for errors

  3. Review Permissions:

    • Confirm story is not restricted
    • Check user permissions for viewing
    • Verify moderation filters aren’t hiding all comments

  4. Test Directly:

    Terminal window
    curl https://example-app.klutch.sh/api/stories/story-id/comments

Issue 2: Moderation Queue Not Loading

Symptoms: Moderation dashboard shows no flagged comments, queue appears broken

Solutions:

  1. Check Moderator Permissions:

    • Verify user has moderator role
    • Confirm moderator account is active
    • Check permission levels

  2. Verify Flagging is Enabled:

    • Confirm MODERATION_ENABLED=true
    • Check COMMENT_QUEUE_ENABLED=true
    • Verify flag reasons are configured

  3. Review Logs:

    • Check application logs for errors
    • Look for database connection issues
    • Verify Redis is connected

  4. Test Flagging:

    • Manually flag a comment
    • Verify flag appears in system
    • Check database directly

Issue 3: Comment Submission Slow or Failing

Symptoms: Comments take long to post, submission fails with timeout

Solutions:

  1. Check Database:

    • Verify MongoDB connection is working
    • Monitor query performance
    • Check connection pool limits

  2. Review Resource Usage:

    • Monitor CPU during peak usage
    • Check memory availability
    • Review disk I/O

  3. Optimize Database:

    • Ensure proper indexes exist
    • Check for slow queries
    • Archive old comments if needed

  4. Increase Limits:

    • Increase MONGODB_POOL_SIZE if needed
    • Upgrade Klutch.sh resources
    • Consider database scaling

Issue 4: Real-Time Updates Not Working

Symptoms: Comments appear with delay, WebSocket disconnects

Solutions:

  1. Verify Redis Connection:

    • Check REDIS_URI is correct
    • Verify Redis is running and accessible
    • Test Redis connectivity

  2. Check WebSocket:

    • Verify port 5000 is accessible
    • Check CORS configuration
    • Test WebSocket with browser dev tools

  3. Monitor Network:

    • Check for network timeouts
    • Verify no firewall blocks
    • Review load balancer configuration

  4. Increase Resources:

    • WebSocket connections are CPU-bound
    • Add more cores for more concurrent connections
    • Upgrade memory for larger caches

Issue 5: High Memory Usage

Symptoms: Memory warnings, application slowness, crashes

Solutions:

  1. Monitor Memory:

    • Track memory growth over time
    • Profile for memory leaks
    • Check comment cache size

  2. Optimize Settings:

    • Reduce comment cache TTL
    • Implement periodic cache clearing
    • Optimize database query results

  3. Upgrade Resources:

    • Increase RAM allocation on Klutch.sh
    • Adjust MongoDB cache size
    • Monitor during peak hours

Issue 6: Email Notifications Not Working

Symptoms: Users don’t receive comment notifications or verification emails

Solutions:

  1. Verify SMTP Settings:

    • Check SMTP_HOST is correct
    • Verify SMTP_PORT (587 for TLS, 465 for SSL)
    • Confirm email and password are correct

  2. Test Email Delivery:

    • Send test email from admin panel
    • Check spam folder
    • Review email provider logs

  3. Check Logs:

    • Review application logs for SMTP errors
    • Verify email configuration in database
    • Check for rate limiting issues

  4. Provider Issues:

    • Gmail requires app-specific passwords
    • Some providers require IP whitelisting
    • Verify sender email is authorized

Custom Domain Setup

Using a custom domain makes your community feel like an integral part of your brand.

Step 1: Add Domain in Klutch.sh

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

Step 2: Update DNS

Update your domain provider’s DNS records:

Type: CNAME
Name: community
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://community.example.com

  3. Certificate is automatically renewed (no action needed)

Step 4: Update Coral Configuration

Update environment variables and integrations:

  1. Update APP_URL to point to new domain
  2. Update CORS_ORIGINS if restricting
  3. Update embed script URLs in website
  4. Update email domain in SMTP_FROM if needed
  5. Test from new domain

Production Best Practices

Backup Strategy

What to Back Up:

  1. MongoDB database (all comments, users, stories)
  2. Application configuration
  3. Moderation settings and policies
  4. User accounts and roles

Backup Schedule:

  • Daily: Automated full backup
  • Weekly: Backup verification test
  • Monthly: Archive backups for compliance

Backup Commands:

For MongoDB:

Terminal window
mongodump --uri="mongodb://user:pass@host/coral" --archive=/backup/coral-$(date +%Y%m%d).archive --gzip

For local database:

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

Backup Storage:

  • Store offsite backups (cloud storage)
  • Encrypt backup archives
  • Document recovery procedures

Monitoring and Alerting

Key Metrics:

  • Comment submission latency
  • Moderation queue depth
  • Active user count
  • Database query performance
  • WebSocket connection count
  • Memory and CPU usage

Alerts:

  • CPU > 80% sustained
  • Memory > 90% capacity
  • Database latency > 500ms
  • Failed comment submissions
  • Backup failures

Scaling Strategy

Vertical Scaling (larger server):

  • Increase CPU cores for WebSocket connections
  • Add RAM for caching and buffers
  • Use faster storage for database

Horizontal Scaling (multiple servers):

  • Multiple API instances behind load balancer
  • Dedicated MongoDB with replication
  • Redis cluster for caching
  • Separate moderation server

When to Scale:

  • Comment latency degrading
  • CPU consistently > 70%
  • Memory consistently > 80%
  • WebSocket connections nearing limit

Community Management

Regular Tasks:

  • Review moderation logs daily
  • Check community health metrics
  • Address flagged comments
  • Communicate with community

User Management:

  • Monitor new user signups
  • Review repeat offenders
  • Implement tiered suspension system
  • Document moderation decisions

Conclusion

You now have a production-ready Coral deployment running on Klutch.sh. Your community has a powerful platform for meaningful discussions backed by professional moderation tools.

Coral brings quality community engagement to publishers and platforms. Real-time discussions, intelligent moderation, and user engagement features work together to build communities where good conversations thrive.

The deployment you’ve built handles real-time WebSocket communication, persistent discussion storage, and complex moderation workflows reliably. Scale it as your community grows, monitor performance metrics, and maintain backups of your community discussions.

Whether you’re a news organization building reader loyalty, a SaaS platform fostering user communities, or any organization seeking healthier online discussions, Coral provides the foundation for thriving communities.

For additional help, check out the Coral documentation, explore moderation strategies, and join the community for support and best practices.

Happy discussing!