Deploying Dittofeed

Introduction

Dittofeed is an open-source customer engagement and messaging platform designed for modern marketing automation. As a privacy-focused alternative to platforms like Customer.io and Braze, Dittofeed empowers businesses to send personalized, targeted messages across multiple channels including email, SMS, push notifications, and webhooks. Built with a developer-first approach, it offers powerful segmentation, journey orchestration, and real-time event tracking capabilities.

Dittofeed stands out for its:

Open Source & Self-Hosted: Complete control over your customer data and infrastructure
Multi-Channel Messaging: Email, SMS, push notifications, and webhooks from a single platform
Advanced Segmentation: Create sophisticated user segments based on behavior, attributes, and events
Journey Builder: Visual workflow editor for complex customer journeys and automated campaigns
Real-Time Processing: Handle events and trigger messages in real-time with low latency
Developer-Friendly: Comprehensive REST API and SDKs for easy integration
Privacy-Focused: GDPR and CCPA compliant with full data ownership
Scalable Architecture: Built on modern technologies including Node.js, PostgreSQL, and ClickHouse

This comprehensive guide walks you through deploying Dittofeed on Klutch.sh using Docker, including detailed installation steps, sample configurations, database setup with persistent storage, and production-ready best practices to help you build world-class customer engagement workflows.

Prerequisites

Before you begin, ensure you have the following:

A Klutch.sh account
A GitHub account with a repository for your Dittofeed project
Docker installed locally for testing (optional but recommended)
Basic understanding of Docker, Node.js, and relational databases
Access to a PostgreSQL database (you can deploy one on Klutch.sh or use a managed service)

Installation and Setup

Step 1: Create Your Project Directory

First, create a new directory for your Dittofeed deployment project:

mkdir dittofeed-klutch
cd dittofeed-klutch
git init

Step 2: Create the Dockerfile

Create a Dockerfile in your project root directory. This will define your Dittofeed container configuration:

FROM node:18-alpine

# Set working directory
WORKDIR /app

# Install dependencies
RUN apk add --no-cache \
    postgresql-client \
    curl \
    bash

# Clone Dittofeed repository
RUN git clone https://github.com/dittofeed/dittofeed.git . && \
    npm ci --production

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

# Expose the default Dittofeed port
EXPOSE 3000

# Set environment variables (will be overridden by Klutch.sh)
ENV NODE_ENV=production
ENV DATABASE_URL=postgresql://user:password@localhost:5432/dittofeed
ENV PORT=3000

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

# Start Dittofeed
CMD ["npm", "start"]

Note: This Dockerfile uses the official Dittofeed repository. For production deployments, consider pinning to a specific version or release tag.

Step 3: Advanced Dockerfile with Build Optimization

For a production-optimized setup with multi-stage builds:

# Build stage
FROM node:18-alpine AS builder

WORKDIR /app

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

# Clone and build Dittofeed (use latest or pin to specific version)
RUN git clone --depth 1 https://github.com/dittofeed/dittofeed.git .
RUN npm ci
RUN npm run build

# Production stage
FROM node:18-alpine

WORKDIR /app

# Install runtime dependencies
RUN apk add --no-cache \
    postgresql-client \
    curl \
    bash \
    dumb-init

# Copy built application from builder
COPY --from=builder /app ./

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

# Switch to non-root user
USER node

# Expose port
EXPOSE 3000

# Environment variables
ENV NODE_ENV=production
ENV PORT=3000

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

# Use dumb-init to handle signals properly
ENTRYPOINT ["/usr/bin/dumb-init", "--"]
CMD ["npm", "start"]

Step 4: Create Environment Configuration

Create a .env.example file to document the required environment variables:

# Dittofeed Configuration
NODE_ENV=production
PORT=3000

# Database Configuration (PostgreSQL)
DATABASE_URL=postgresql://username:password@postgres-host:5432/dittofeed
DATABASE_POOL_MIN=2
DATABASE_POOL_MAX=10

# Redis Configuration (for caching and queues)
REDIS_URL=redis://redis-host:6379

# Security & Authentication
SECRET_KEY=your-secret-key-here-change-this
JWT_SECRET=your-jwt-secret-here-change-this
SESSION_SECRET=your-session-secret-here-change-this

# Email Provider Configuration (choose one)
# Sendgrid
SENDGRID_API_KEY=your-sendgrid-api-key

# AWS SES
AWS_REGION=us-east-1
AWS_ACCESS_KEY_ID=your-aws-access-key
AWS_SECRET_ACCESS_KEY=your-aws-secret-key

# Postmark
POSTMARK_API_KEY=your-postmark-api-key

# SMS Provider Configuration (optional)
TWILIO_ACCOUNT_SID=your-twilio-account-sid
TWILIO_AUTH_TOKEN=your-twilio-auth-token
TWILIO_PHONE_NUMBER=+1234567890

# Application URLs
BASE_URL=https://example-app.klutch.sh
DASHBOARD_URL=https://example-app.klutch.sh

# Worker Configuration
ENABLE_WORKER=true
WORKER_CONCURRENCY=5

# Logging
LOG_LEVEL=info
LOG_FORMAT=json

# Analytics & Tracking
SEGMENT_WRITE_KEY=your-segment-key
ANALYTICS_ENABLED=true

Security Note: Never commit actual passwords, API keys, or sensitive data to your repository. Always use environment variables in Klutch.sh dashboard.

Step 5: Create Database Migration Script

Create a scripts/init-db.sh file for database initialization:

#!/bin/bash
set -e

echo "Waiting for PostgreSQL to be ready..."
until pg_isready -h $DB_HOST -U $DB_USER; do
  echo "Waiting for database..."
  sleep 2
done

echo "Running database migrations..."
npm run migrate

echo "Seeding initial data..."
npm run seed

echo "Database initialization complete!"

Make the script executable:

chmod +x scripts/init-db.sh

Step 6: Test Locally with Docker Compose (Optional)

For local development and testing, create a docker-compose.yml file:

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: dittofeed
      POSTGRES_PASSWORD: dittofeed_password
      POSTGRES_DB: dittofeed
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U dittofeed"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  dittofeed:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgresql://dittofeed:dittofeed_password@postgres:5432/dittofeed
      REDIS_URL: redis://redis:6379
      NODE_ENV: development
      PORT: 3000
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs

volumes:
  postgres_data:
  redis_data:

Test your setup locally:

# Build and start services
docker-compose up -d

# View logs
docker-compose logs -f dittofeed

# Access Dittofeed at http://localhost:3000

# Stop and clean up
docker-compose down -v

Note: Docker Compose is for local development only. Klutch.sh does not support Docker Compose for deployment. For production on Klutch.sh, deploy PostgreSQL and Redis as separate apps.

Step 7: Create Sample Configuration Files

Create a config/production.json file for production settings:

{
  "app": {
    "name": "Dittofeed",
    "environment": "production",
    "port": 3000
  },
  "database": {
    "connection": "postgresql",
    "pool": {
      "min": 2,
      "max": 10
    },
    "migrations": {
      "directory": "./migrations",
      "tableName": "knex_migrations"
    }
  },
  "messaging": {
    "providers": {
      "email": {
        "default": "sendgrid"
      },
      "sms": {
        "default": "twilio"
      }
    },
    "rateLimit": {
      "email": 100,
      "sms": 50
    }
  },
  "worker": {
    "enabled": true,
    "concurrency": 5,
    "retries": 3,
    "backoff": {
      "type": "exponential",
      "delay": 1000
    }
  },
  "logging": {
    "level": "info",
    "format": "json"
  }
}

Step 8: Create Getting Started Sample Code

Create a examples/quickstart.js file with sample integration code:

const DittofeedClient = require('@dittofeed/sdk-node');

// Initialize the Dittofeed client
const client = new DittofeedClient({
  apiKey: process.env.DITTOFEED_API_KEY,
  host: 'https://example-app.klutch.sh'
});

// Example 1: Track a user event
async function trackUserEvent() {
  await client.track({
    userId: 'user_123',
    event: 'Product Viewed',
    properties: {
      productId: 'prod_456',
      productName: 'Premium Subscription',
      price: 49.99,
      currency: 'USD'
    },
    timestamp: new Date()
  });
  console.log('Event tracked successfully!');
}

// Example 2: Identify a user
async function identifyUser() {
  await client.identify({
    userId: 'user_123',
    traits: {
      email: 'user@example.com',
      firstName: 'John',
      lastName: 'Doe',
      plan: 'premium',
      signupDate: '2024-01-15'
    }
  });
  console.log('User identified successfully!');
}

// Example 3: Send a transactional email
async function sendTransactionalEmail() {
  await client.sendMessage({
    userId: 'user_123',
    templateId: 'welcome_email',
    channel: 'email',
    data: {
      userName: 'John',
      verificationLink: 'https://example.com/verify/abc123'
    }
  });
  console.log('Email sent successfully!');
}

// Example 4: Add user to a segment
async function addUserToSegment() {
  await client.addToSegment({
    userId: 'user_123',
    segmentId: 'premium_users'
  });
  console.log('User added to segment!');
}

// Run examples
async function main() {
  try {
    await identifyUser();
    await trackUserEvent();
    await sendTransactionalEmail();
    await addUserToSegment();
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

Step 9: Push to GitHub

Commit your Dockerfile and configuration files to your GitHub repository:

git add Dockerfile .env.example config/ examples/ scripts/
git commit -m "Add Dittofeed Dockerfile and configuration for Klutch.sh deployment"
git remote add origin https://github.com/yourusername/dittofeed-klutch.git
git push -u origin main

Deploying to Klutch.sh

Now that your Dittofeed project is ready and pushed to GitHub, follow these steps to deploy it on Klutch.sh with persistent storage and proper configuration.

Deployment Steps

Set Up PostgreSQL Database

Before deploying Dittofeed, you need a PostgreSQL database. You can either:
- Deploy PostgreSQL on Klutch.sh as a separate app (recommended for production)
- Use a managed PostgreSQL service like AWS RDS, Google Cloud SQL, or ElephantSQL
If deploying PostgreSQL on Klutch.sh:
- Create a new app with a PostgreSQL Docker image
- Select TCP as the traffic type
- Set the internal port to 5432 (PostgreSQL’s default port)
- Connect to it on port 8000 from other apps
- Attach a persistent volume with mount path /var/lib/postgresql/data
- Set the volume size based on expected data (minimum 10GB recommended)
Log in to Klutch.sh

Navigate to klutch.sh/app and sign in to your account.
Create a New Project

Go to Create Project and give your project a meaningful name (e.g., “Dittofeed Production”).
Create a New App

Navigate to Create App and configure the following settings:
Select Your Repository
- Choose GitHub as your Git source
- Select the repository containing your Dockerfile
- Choose the branch you want to deploy (usually main or master)
Note: Klutch.sh will automatically detect the Dockerfile in your repository root.
Configure Traffic Type
- Traffic Type: Select HTTP (Dittofeed serves a web dashboard and API via HTTP)
- Internal Port: Set to 3000 (the default port that Dittofeed listens on)
Set Environment Variables

Add the following environment variables for your Dittofeed configuration. These are critical for proper operation:

Core Configuration:
- NODE_ENV: Set to production
- PORT: Set to 3000
- BASE_URL: Your app URL (e.g., https://example-app.klutch.sh)
Database Configuration:
- DATABASE_URL: PostgreSQL connection string
  - If using Klutch.sh PostgreSQL: postgresql://username:password@postgres-app.klutch.sh:8000/dittofeed
  - If using external service: Use the provided connection string
- DATABASE_POOL_MIN: Set to 2
- DATABASE_POOL_MAX: Set to 10
Security Secrets: (Generate secure random strings)
- SECRET_KEY: Use a strong random string (32+ characters)
- JWT_SECRET: Use a strong random string (32+ characters)
- SESSION_SECRET: Use a strong random string (32+ characters)
Email Provider (Choose one):
- For SendGrid: SENDGRID_API_KEY
- For AWS SES: AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
- For Postmark: POSTMARK_API_KEY
Optional - SMS Provider:
- TWILIO_ACCOUNT_SID
- TWILIO_AUTH_TOKEN
- TWILIO_PHONE_NUMBER
Optional - Redis (for caching and job queues):
- REDIS_URL: Redis connection string (deploy Redis separately on Klutch.sh or use a managed service)
Worker Configuration:
- ENABLE_WORKER: Set to true
- WORKER_CONCURRENCY: Set to 5
Logging:
- LOG_LEVEL: Set to info (or debug for troubleshooting)
- LOG_FORMAT: Set to json
Security Note: Always use strong, unique passwords and API keys for production deployments. Never commit these values to your repository.
Attach Persistent Volumes

This is critical for ensuring your application data persists across deployments and restarts:
- In the Volumes section, click “Add Volume”
- Mount Path: Enter /app/data (for application data and uploads)
- Size: Choose an appropriate size based on your expected usage (minimum 5GB, 20GB+ recommended for production)
Optional - Additional Volume for Logs:
- Add another volume
- Mount Path: Enter /app/logs
- Size: 5-10GB should be sufficient for logs
Important: Dittofeed requires persistent storage to maintain user data, campaign information, and message logs between container restarts.
Configure Additional Settings
- Region: Select the region closest to your users and database for optimal latency
- Compute Resources:
  - Minimum: 1 CPU, 2GB RAM for small deployments
  - Recommended: 2 CPUs, 4GB RAM for production workloads
  - Scale up based on your user base and message volume
- Instances: Start with 1 instance (you can scale horizontally later as traffic grows)
Deploy Your Application

Click “Create” to start the deployment. Klutch.sh will:
- Automatically detect your Dockerfile in the repository root
- Build the Docker image using your Dockerfile
- Attach the persistent volumes
- Start your Dittofeed container with the configured environment variables
- Assign a URL for external access
The build process may take 5-10 minutes depending on the image size and dependencies.
Run Database Migrations

After the initial deployment, you need to set up the database schema:
- Access your app’s logs in the Klutch.sh dashboard
- Verify the app is running and connected to the database
- The migrations should run automatically on first startup
- Check the logs for any migration errors
If migrations don’t run automatically, you can use Nixpacks environment variables:
- Set BUILD_COMMAND to include migration steps if needed
Access Your Dittofeed Dashboard

Once deployment is complete, you’ll receive a URL like example-app.klutch.sh. Navigate to this URL in your browser to access your Dittofeed dashboard:
```
https://example-app.klutch.sh
```
Create your admin account and start configuring your customer engagement campaigns!

Configuring Dittofeed for Production

Setting Up Email Templates

After deployment, configure your email templates in the Dittofeed dashboard:

Navigate to Templates in the dashboard
Click Create New Template
Choose template type (email, SMS, push notification)
Design your template using the visual editor or HTML
Add dynamic variables using Liquid syntax: {{ user.firstName }}
Test your template with sample data
Save and activate the template

Creating User Segments

Set up user segments for targeted messaging:

Go to Segments in the dashboard
Click Create New Segment
Define segment criteria:
- User attributes (e.g., plan = 'premium')
- Behavioral events (e.g., viewed product in last 7 days)
- Custom properties
Preview segment size and user list
Save the segment for use in campaigns

Building Customer Journeys

Create automated customer journeys:

Navigate to Journeys in the dashboard
Click Create New Journey
Use the visual workflow builder to:
- Define entry conditions (e.g., user signed up)
- Add steps (email, wait, condition, SMS)
- Set up branching logic
- Configure exit conditions
Test the journey with test users
Activate the journey for your user base

Integrating Dittofeed with Your Application

JavaScript/Node.js Integration

Install the Dittofeed SDK:

npm install @dittofeed/sdk-node

Initialize in your application:

const DittofeedClient = require('@dittofeed/sdk-node');

const dittofeed = new DittofeedClient({
  apiKey: process.env.DITTOFEED_API_KEY,
  host: 'https://example-app.klutch.sh'
});

// Track user signup
await dittofeed.track({
  userId: user.id,
  event: 'User Signed Up',
  properties: {
    plan: 'premium',
    source: 'website'
  }
});

// Send a welcome email
await dittofeed.sendMessage({
  userId: user.id,
  templateId: 'welcome_email',
  channel: 'email'
});

Python Integration

pip install dittofeed-python

from dittofeed import Client

client = Client(
    api_key=os.environ.get('DITTOFEED_API_KEY'),
    host='https://example-app.klutch.sh'
)

# Track event
client.track(
    user_id='user_123',
    event='Product Purchased',
    properties={
        'product_id': 'prod_456',
        'amount': 99.99,
        'currency': 'USD'
    }
)

# Identify user
client.identify(
    user_id='user_123',
    traits={
        'email': 'user@example.com',
        'name': 'John Doe',
        'plan': 'enterprise'
    }
)

REST API Integration

For other languages, use the REST API directly:

# Track an event
curl -X POST https://example-app.klutch.sh/api/v1/track \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "userId": "user_123",
    "event": "Page Viewed",
    "properties": {
      "page": "/pricing",
      "referrer": "google"
    }
  }'

# Send a message
curl -X POST https://example-app.klutch.sh/api/v1/messages/send \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "userId": "user_123",
    "templateId": "password_reset",
    "channel": "email",
    "data": {
      "resetLink": "https://example.com/reset/abc123"
    }
  }'

Monitoring and Performance

Health Checks

Dittofeed includes built-in health check endpoints:

Health Check: GET /health - Returns 200 if the application is running
Readiness Check: GET /ready - Returns 200 if the application is ready to receive traffic
Database Check: GET /health/db - Returns 200 if the database connection is healthy

Monitor these endpoints to ensure your deployment is healthy.

Logging and Debugging

View application logs in the Klutch.sh dashboard:

Navigate to your app in the dashboard
Click on the Logs tab
Filter by log level (info, warn, error)
Use search to find specific events

Set LOG_LEVEL=debug for detailed troubleshooting information.

Performance Monitoring

Monitor key metrics:

Message Delivery Rate: Track successful vs. failed message deliveries
API Response Time: Monitor endpoint latency
Database Query Performance: Watch for slow queries
Worker Queue Length: Ensure background jobs are processing efficiently
Memory and CPU Usage: Scale compute resources as needed

Scaling Recommendations

Scale Dittofeed based on usage:

< 10,000 users: 1 instance, 2GB RAM, 1 CPU
10,000 - 100,000 users: 2-3 instances, 4GB RAM, 2 CPUs each
100,000+ users: 3+ instances, 8GB RAM, 4 CPUs each
High message volume: Consider deploying separate worker instances

Persistent Storage Configuration

Data Directory Structure

Dittofeed uses the /app/data directory for:

Uploads: User-uploaded files and assets
Exports: Data exports and reports
Cache: Temporary cached data
Attachments: Email attachment storage

Ensure your persistent volume has adequate space for these files.

Database Backups

Implement regular database backups:

If using Klutch.sh PostgreSQL, create a backup schedule
For external databases, use the provider’s backup features
Store backups in a separate location (e.g., S3)
Test backup restoration regularly

Log Rotation

Configure log rotation to prevent disk space issues:

# In your Dockerfile or startup script
RUN npm install -g pm2
ENV PM2_LOG_ROTATE=true
ENV PM2_LOG_MAX_SIZE=100M
ENV PM2_LOG_RETAIN=7

Security Best Practices

Environment Variables Security

Never commit sensitive credentials to Git
Use Klutch.sh’s secret management features
Rotate API keys and secrets regularly
Use different credentials for development and production

API Security

Enable API rate limiting to prevent abuse
Use HTTPS for all API requests (automatic on Klutch.sh)
Implement IP whitelisting for admin endpoints
Monitor API access logs for suspicious activity

Database Security

Use strong, unique passwords for database access
Enable SSL/TLS for database connections
Restrict database access to only necessary IP addresses
Regular security updates and patches

Authentication & Authorization

Implement strong password policies
Enable two-factor authentication for admin accounts
Use role-based access control (RBAC)
Audit user access logs regularly

Customizing Dittofeed with Nixpacks

If you need to customize the build or start process without using a Dockerfile, you can use Nixpacks environment variables:

Custom Build Command

Set the BUILD_COMMAND environment variable:

BUILD_COMMAND="npm ci && npm run build && npm run migrate"

Custom Start Command

Set the START_COMMAND environment variable:

START_COMMAND="node dist/index.js"

Custom Install Command

Set the INSTALL_COMMAND environment variable:

INSTALL_COMMAND="npm ci --production"

However, for Dittofeed, using a Dockerfile is strongly recommended for full control over dependencies and configuration.

Troubleshooting Common Issues

Application Won’t Start

Issue: Container starts but application doesn’t respond

Solutions:

Check logs for database connection errors
Verify DATABASE_URL is correctly formatted
Ensure PostgreSQL is accessible on the specified port
Verify all required environment variables are set

Database Connection Failed

Issue: Cannot connect to PostgreSQL database

Solutions:

Verify database is running and accessible
Check connection string format: postgresql://user:password@host:port/database
For Klutch.sh PostgreSQL apps, use port 8000 for external connections
Ensure database user has proper permissions

Email Delivery Issues

Issue: Emails are not being sent

Solutions:

Verify email provider API keys are correct
Check email provider status and quotas
Review Dittofeed logs for delivery errors
Test email provider credentials independently
Ensure sender email is verified with provider

High Memory Usage

Issue: Application consuming too much memory

Solutions:

Increase compute resources in Klutch.sh
Optimize database queries
Reduce WORKER_CONCURRENCY if processing too many jobs
Check for memory leaks in custom code
Enable connection pooling with appropriate limits

Slow Performance

Issue: API endpoints responding slowly

Solutions:

Enable Redis caching for improved performance
Optimize database indexes
Increase compute resources
Scale to multiple instances
Review and optimize slow database queries

Advanced Configuration

Setting Up Redis for Caching

Deploy Redis on Klutch.sh to improve performance:

Create a new app with Redis Docker image
Select TCP as traffic type
Set internal port to 6379
Add REDIS_URL environment variable to Dittofeed app
Format: redis://redis-app.klutch.sh:8000

Configuring Worker Processes

For high-volume message processing, deploy dedicated worker instances:

Create a new app with the same repository
Set environment variable WORKER_ONLY=true
Configure WORKER_CONCURRENCY based on expected load
Use the same database and Redis connections

Custom Domain Setup

Configure a custom domain for your Dittofeed instance:

Navigate to your app in Klutch.sh dashboard
Go to Settings > Domains
Add your custom domain (e.g., dittofeed.yourdomain.com)
Update DNS records as instructed
Update BASE_URL environment variable to your custom domain
SSL certificates are automatically provisioned

For more information, see the Custom Domains documentation.

Webhook Configuration

Set up webhooks to receive events from Dittofeed:

In Dittofeed dashboard, go to Settings > Webhooks
Add webhook URL endpoint
Select events to trigger webhooks
Configure retry logic and authentication
Test webhook delivery with sample events

Production Deployment Checklist

Before going to production, ensure you have:

Resources and Documentation

Conclusion

Deploying Dittofeed on Klutch.sh provides a powerful, scalable foundation for building sophisticated customer engagement workflows. With Docker containerization, persistent storage, and automated deployments through GitHub integration, you can focus on creating compelling messaging campaigns while Klutch.sh handles the infrastructure.

This guide has covered everything from initial setup and configuration to production deployment and optimization. Whether you’re building a simple email automation system or a complex multi-channel customer engagement platform, Dittofeed on Klutch.sh gives you the flexibility and control you need.

For advanced customizations, you can extend Dittofeed with plugins, integrate with external systems via webhooks, deploy dedicated worker instances for high-volume processing, or implement custom analytics and reporting. The combination of Dittofeed’s powerful features and Klutch.sh’s reliable infrastructure creates an ideal environment for modern customer engagement applications.

If you encounter any issues or have questions, refer to the troubleshooting section above or consult the official Dittofeed documentation and Klutch.sh support resources.