DEV Community: Jaskaran Deogan

Deploy n8n with Coolify: Self-Hosted Automation in Minutes

Jaskaran Deogan — Mon, 13 Oct 2025 14:00:00 +0000

Self-hosting n8n gives you unlimited workflow executions, full data control, and zero monthly fees. With Coolify, you can deploy a production-ready n8n instance in just a few clicks.

Why Self-Host n8n?

n8n is an open-source workflow automation tool that connects apps and services without code. Self-hosting means unlimited executions, complete data ownership, and significant cost savings at scale.

What You Get with Coolify

Coolify deploys n8n with a production-ready architecture including:

n8n main instance - The web interface and workflow editor
n8n-worker - Background execution for better performance
PostgreSQL - Database for workflows and execution history
Redis - Message queue for distributed processing Plus automatic SSL certificates, container management, and built-in monitoring.

Deployment Steps

Prerequisites

A Coolify instance running on your server
A domain or subdomain pointed to your server (e.g., n8n.yourdomain.com)

Step 1: Create a New Project

In your Coolify dashboard, create a new project to organize your n8n deployment.

Step 2: Add the n8n Service

Select "Add New Resource" and choose the n8n service from Coolify's catalog. This automatically uses the Docker Compose configuration with all necessary services.

Step 3: Configure Your Domain

Set the SERVICE_URL_N8N environment variable:

SERVICE_URL_N8N=https://n8n.yourdomain.com

This tells n8n where it's publicly accessible, which is essential for webhooks and external integrations.

Step 4: Deploy and Restart

Deploy the service, then restart it. This restart allows Coolify to generate SSL certificates and apply the domain configuration properly. Within moments, you'll have n8n running with HTTPS enabled automatically.

Step 5: Initial Setup and Activation

Navigate to your n8n URL (e.g., https://n8n.yourdomain.com):

Create Your Admin Account - Set up your username and password
Activation Popup - n8n will display a popup asking you to activate your instance
Enter Your Email - Provide your email address
Receive Your Key - n8n will email you an activation key that unlocks community features

The activation is optional but recommended for access to additional features like advanced permissions and extra integrations.

Managing Your Instance

Logs: View logs for all services directly from Coolify's dashboard.
Scaling: Add more worker instances as your automation needs grow.
Backups: Set up automated backups through Coolify to protect your workflows.
Updates: Pull the latest n8n image and redeploy when new versions are released.

Why This Works

Deploying n8n manually requires managing Docker files, configuring reverse proxies, and handling SSL certificates. Coolify handles all of that automatically:

One-click deployment with production-ready configuration
Automatic HTTPS with Let's Encrypt
Easy scaling and management
All controls in one dashboard

Ready to automate? deploy n8n, and start connecting your tools in minutes.

Resources:

Coolify Documentation
n8n Documentation
n8n Community Forum

Self-Hosting Listmonk with Coolify: Your Own Newsletter Platform in Minutes

Jaskaran Deogan — Mon, 22 Sep 2025 00:24:21 +0000

Are you tired of paying monthly fees for newsletter services like Mailchimp or ConvertKit? Looking for complete control over your subscriber data and email campaigns? Listmonk might be exactly what you need.

Listmonk is a powerful, self-hosted newsletter and mailing list manager that gives you all the features of premium services without the recurring costs or subscriber limits. Combined with Coolify for easy deployment, you can have your own email marketing platform running in under 30 minutes.

Why Choose Listmonk?

Before diving into the setup, let's look at why Listmonk stands out:

✅ Cost-effective: No monthly fees or subscriber limits
✅ Privacy-focused: Complete control over your data
✅ Feature-rich: Campaign analytics, segmentation, templates, and more
✅ Modern UI: Clean, intuitive interface that rivals paid services
✅ API-first: Integrate with your existing applications
✅ Open source: Actively maintained with a growing community

Prerequisites

Before we start, make sure you have:

A server or VPS with Docker support
Coolify installed and configured
A domain name pointed to your server
SMTP credentials (Gmail, SendGrid, AWS SES, etc.)

The Setup Process

Step 1: Create Your Listmonk Service in Coolify

Log into your Coolify dashboard
Create a new project or use an existing one
Add a new resource and choose "Docker Compose"
Name your service (e.g., "listmonk-newsletter")

Step 2: Configure Your Docker Compose

Here's the complete docker-compose.yml configuration that works perfectly with Coolify:

x-db-credentials:
  POSTGRES_USER: listmonk
  POSTGRES_PASSWORD: listmonk
  POSTGRES_DB: listmonk

services:
  app:
    image: 'listmonk/listmonk:latest'
    container_name: listmonk_app
    restart: unless-stopped
    ports:
      - '9000:9000'
    networks:
      - listmonk
    hostname: '${SERVICE_FQDN_APP:-listmonk.example.com}'
    depends_on:
      db:
        condition: service_healthy
    command:
      - sh
      - '-c'
      - "./listmonk --install --idempotent --yes --config '' && ./listmonk --upgrade --yes --config '' && ./listmonk --config ''"
    environment:
      LISTMONK_app__address: '0.0.0.0:9000'
      LISTMONK_app__root_url: '${LISTMONK_app__root_url}'
      LISTMONK_db__user: listmonk
      LISTMONK_db__password: listmonk
      LISTMONK_db__database: listmonk
      LISTMONK_db__host: db
      LISTMONK_db__port: 5432
      LISTMONK_db__ssl_mode: disable
      LISTMONK_db__max_open: 25
      LISTMONK_db__max_idle: 25
      LISTMONK_db__max_lifetime: 300s
      TZ: Etc/UTC
      LISTMONK_ADMIN_USER: '${LISTMONK_ADMIN_USER}'
      LISTMONK_ADMIN_PASSWORD: '${LISTMONK_ADMIN_PASSWORD}'
    volumes:
      - './uploads:/listmonk/uploads:rw'
    healthcheck:
      test:
        - CMD
        - wget
        - '--no-verbose'
        - '--tries=1'
        - '--spider'
        - 'http://localhost:9000/'
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    image: 'postgres:17-alpine'
    container_name: listmonk_db
    restart: unless-stopped
    networks:
      - listmonk
    environment:
      POSTGRES_USER: listmonk
      POSTGRES_PASSWORD: listmonk
      POSTGRES_DB: listmonk
    healthcheck:
      test:
        - CMD-SHELL
        - 'pg_isready -U listmonk'
      interval: 10s
      timeout: 5s
      retries: 6
    volumes:
      - type: volume
        source: listmonk-data
        target: /var/lib/postgresql/data

networks:
  listmonk: null

volumes:
  listmonk-data: null

Step 3: Set Environment Variables

In your Coolify service settings, add these environment variables:

# Required - Set your admin credentials
LISTMONK_ADMIN_USER=your-admin-username
LISTMONK_ADMIN_PASSWORD=your-secure-password

# Required - Your domain configuration
SERVICE_FQDN_APP=newsletter.yourdomain.com
LISTMONK_app__root_url=https://newsletter.yourdomain.com

Security Note: Make sure to use a strong password for your admin account!

Step 4: Deploy and Access

Save your configuration in Coolify
Deploy the service
Wait for both containers to become healthy (usually 2-3 minutes)
Access your Listmonk instance at https://newsletter.yourdomain.com

Initial Configuration

Once Listmonk is running, you'll need to configure it:

1. First Login

Navigate to your domain
Login with the credentials you set in environment variables
You'll be greeted with the clean Listmonk dashboard

2. Configure SMTP Settings

Go to Settings > SMTP and add your email provider:

{
  "host": "smtp.gmail.com",
  "port": 587,
  "auth_protocol": "plain",
  "username": "your-email@gmail.com",
  "password": "your-app-password",
  "hello_hostname": "",
  "tls_enabled": true,
  "tls_skip_verify": false,
  "max_conns": 10,
  "idle_timeout": "15s",
  "wait_timeout": "5s",
  "max_msg_retries": 2,
  "email_headers": []
}

3. Create Your First List

Go to Lists and create your first mailing list
Set up subscription preferences
Configure double opt-in if needed

4. Design Your Templates

Navigate to Campaigns > Templates
Customize the default template or create your own
Use Listmonk's template variables for personalization

Key Features to Explore

Once you're set up, here are the powerful features you can leverage:

Campaign Management

Rich text editor with template support
A/B testing capabilities
Scheduled sending
Campaign analytics and tracking

Subscriber Management

Import/export subscribers
Custom attributes and segmentation
Subscription preferences
Bounce and complaint handling

API Integration

RESTful API for all operations
Webhook support
Easy integration with your applications

Production Considerations

For a production deployment, consider these improvements:

Database Security

# Change default credentials
POSTGRES_USER: your-custom-user
POSTGRES_PASSWORD: your-secure-db-password

Backup Strategy

Set up automated backups for your PostgreSQL data:

# Example backup script
docker exec listmonk_db pg_dump -U listmonk listmonk > backup-$(date +%Y%m%d).sql

Resource Limits

Add resource constraints to your containers:

deploy:
  resources:
    limits:
      memory: 512M
      cpus: '0.5'

Cost Comparison

Let's look at the numbers:

Mailchimp (10,000 subscribers): $99/month = $1,188/year
ConvertKit (10,000 subscribers): $119/month = $1,428/year
Listmonk Self-hosted: VPS ($20/month) = $240/year

Annual savings: $948-$1,188 with complete data ownership!

Troubleshooting Common Issues

Container won't start: Check your environment variables and ensure the database is healthy first.

Can't send emails: Verify your SMTP settings and check if your provider requires app passwords (Gmail) or API keys.

Performance issues: Monitor your database resources and consider upgrading your server if you have a large subscriber base.

Conclusion

Self-hosting Listmonk with Coolify gives you enterprise-grade email marketing capabilities without the recurring costs. You maintain complete control over your data while enjoying a modern, feature-rich platform that scales with your needs.

The initial setup might take 30 minutes, but the long-term benefits in cost savings, privacy, and control make it worthwhile for any serious content creator or business.

Ready to take control of your email marketing? Give Listmonk a try – your subscribers (and your wallet) will thank you!

Have you set up Listmonk with Coolify? Share your experience in the comments below! And if you found this guide helpful, don't forget to ❤️ and follow for more self-hosting tutorials.

Self-Hosted Analytics with Rybbit: A Game-Changer for Privacy-Conscious Developers

Jaskaran Deogan — Sat, 06 Sep 2025 06:39:29 +0000

As AI adoption accelerates day by day, so does the number of people creating web applications. With tools like Loveable and Vercel's V0, it's never been easier to test your ideas and build MVPs that capture the essence of your vision. However, once you transition from prototype to production and start onboarding real users, understanding their behavior becomes crucial.

You need insights into user experience, system performance, and potential errors. You need analytics that tell you everything about the traffic flowing through your website. But here's the thing – can you really trust third-party services with your precious user data?

The Analytics Dilemma: Privacy vs. Convenience

Sure, Google Analytics exists. It's free, feature-rich, and widely adopted. But as more developers embrace the "vibecoding" philosophy and rapid prototyping becomes the norm, trusting third parties with sensitive user data becomes increasingly questionable.

Enter self-sovereign analytics – the idea that you should own and control your analytics data completely. This is where Rybbit absolutely shines, and honestly, I'm blown away by its open-source capabilities.

Why Rybbit Caught My Attention

Rybbit isn't just another analytics tool – it's a complete, self-hosted analytics platform that gives you:

🔒 Complete data ownership - Your data stays on your infrastructure
📊 Real-time insights - Live traffic monitoring and user behavior tracking
🚀 Performance monitoring - Track errors, page load times, and system health
🛡️ Privacy-first approach - No third-party data sharing or tracking
💡 Enhanced Analytics on user testing - Additional tools are available to test the app’s functionality, including enhanced error analytics and user session replays.
📈 Beautiful dashboards - Intuitive interface that rivals commercial solutions
🔧 Full customization - Modify and extend as needed since it's open source

Rybbit Github

Deploying Rybbit on Coolify: The Complete Guide

If you want to simply run Rybbit on your VPS, the official documentation has you covered. But if you're like me and want to deploy it on Coolify with proper health checks and production-ready configuration, this guide is for you.

The Architecture

Rybbit is a multi-service application that requires several components working in harmony:

Frontend: Next.js client (port 3002)
Backend: Fastify API server (port 3001)
Database: PostgreSQL for user data and configuration
Analytics DB: ClickHouse for high-performance analytics storage
Cache: Redis for session management and caching
Reverse Proxy: Handled automatically by Coolify

Step 1: Setting Up the Docker Compose Configuration

The magic happens in the coolify-compose.yml file. Here's the production-ready configuration with health checks:

services:
  clickhouse:
    image: clickhouse/clickhouse-server:25.4.2
    volumes:
      - clickhouse-data:/var/lib/clickhouse
    environment:
      - CLICKHOUSE_DB=${CLICKHOUSE_DB:-analytics}
      - CLICKHOUSE_USER=${CLICKHOUSE_USER:-default}
      - CLICKHOUSE_PASSWORD=${CLICKHOUSE_PASSWORD:-frog}
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8123/ping"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    restart: unless-stopped

  postgres:
    image: postgres:17.4
    environment:
      - POSTGRES_USER=${POSTGRES_USER:-frog}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-frog}
      - POSTGRES_DB=${POSTGRES_DB:-analytics}
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
    restart: unless-stopped
    command: ["redis-server", "--requirepass", "${REDIS_PASSWORD:-changeme}", "--appendonly", "yes"]
    healthcheck:
      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s

  backend:
    build:
      context: .
      dockerfile: ./server/Dockerfile
    environment:
      - NODE_ENV=production
      - CLICKHOUSE_HOST=http://clickhouse:8123
      - POSTGRES_HOST=postgres
      - REDIS_HOST=redis
      - BETTER_AUTH_SECRET=${BETTER_AUTH_SECRET}
      - BASE_URL=${BASE_URL}
      # ... other environment variables
    depends_on:
      clickhouse:
        condition: service_healthy
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: unless-stopped

  client:
    build:
      context: .
      dockerfile: ./client/Dockerfile
      args:
        NEXT_PUBLIC_BACKEND_URL: ${NEXT_PUBLIC_BACKEND_URL}
    environment:
      - NODE_ENV=production
      - NEXT_PUBLIC_BACKEND_URL=${NEXT_PUBLIC_BACKEND_URL}
    depends_on:
      backend:
        condition: service_healthy
    restart: unless-stopped

volumes:
  clickhouse-data:
  postgres-data:
  redis-data:

Step 2: Environment Variables Configuration

Set these in your Coolify application:

# Required
DOMAIN_NAME=analytics.yourdomain.com
BASE_URL=https://analytics.yourdomain.com
BETTER_AUTH_SECRET=your-super-secure-secret-here
NEXT_PUBLIC_BACKEND_URL=https://api.analytics.yourdomain.com

# Database credentials
POSTGRES_USER=frog
POSTGRES_PASSWORD=your-secure-postgres-password
POSTGRES_DB=analytics
CLICKHOUSE_DB=analytics
CLICKHOUSE_PASSWORD=your-secure-clickhouse-password
REDIS_PASSWORD=your-secure-redis-password

# Optional
DISABLE_SIGNUP=false
DISABLE_TELEMETRY=true

Step 3: Deploy in Coolify

Create a new Application in Coolify
Choose Docker Compose as the deployment method
Connect your Git repository
Set the compose file to coolify-compose.yml
Configure all environment variables
Deploy!

Common Issues and Solutions

1. API Proxy Configuration

The most common issue: Frontend can't communicate with the backend.

Solution: Ensure your Next.js configuration properly handles API proxying. The frontend should proxy /api/* calls to the backend service. Make sure NEXT_PUBLIC_BACKEND_URL points to your domain, not the internal backend service.

// client/next.config.ts
const nextConfig = {
  async rewrites() {
    if (process.env.NODE_ENV === 'development') {
      return [
        {
          source: '/api/:path*',
          destination: 'http://backend:3001/api/:path*'
        }
      ]
    }
    return []
  }
}

2. Health Check Failures

Issue: Services failing health checks and restarting continuously.

Solution: Verify that:

Database credentials match across all services
Network connectivity between containers is working
Health check endpoints are responding correctly

# Test backend health
curl -f http://localhost:3001/api/health

# Test database connectivity
docker exec -it postgres-container pg_isready -U frog -d analytics

3. Build Context Issues

Issue: Docker builds failing due to incorrect context or Dockerfile paths.

Solution: Ensure your build context is set to the repository root, and Dockerfile paths are relative to that context:

backend:
  build:
    context: .  # Repository root
    dockerfile: ./server/Dockerfile  # Relative to context

The Benefits of This Setup

🔄 Graceful Service Dependencies

Services start in the correct order with health condition checks:

Databases (PostgreSQL, ClickHouse, Redis) initialize first
Backend waits for all databases to be healthy
Frontend waits for backend to be healthy

🏥 Comprehensive Health Monitoring

Every service includes health checks that Coolify can monitor and act upon automatically.

🚀 Production-Ready Optimizations

Standalone Next.js builds for containerized deployment
Conditional compression loading (zstd with gzip fallback)
Proper restart policies and resource management

Why This Matters

In an era where data privacy is paramount and vendor lock-in is a real concern, self-hosted analytics solutions like Rybbit represent the future. You get:

Complete control over your analytics data
No monthly fees or usage limits
Customization freedom to add features you need
Compliance confidence knowing where your data lives
Performance benefits from local data processing

Final Thoughts

Rybbit on Coolify is a winning combination for developers who value privacy, performance, and control. The setup might seem complex initially, but the payoff is enormous – you get enterprise-grade analytics without the enterprise price tag or privacy concerns.

The open-source nature means you can contribute back to the community, customize it for your specific needs, and never worry about a service shutting down or changing their pricing model.

Have you tried self-hosted analytics? What's been your experience with tools like Rybbit? I'd love to hear your thoughts in the comments!

Resources:

Happy analytics tracking! 📊

How to Self-Host Coolify on Your VPS: A Complete Guide

Jaskaran Deogan — Mon, 12 May 2025 12:00:00 +0000

Deploying applications can be a complex process, especially if you're managing multiple projects. Coolify offers a streamlined solution for developers who want control without the complexity. In this guide, I'll walk you through what Coolify is and how to set it up on your own VPS.

What is Coolify?

Coolify is an open-source, self-hostable alternative to platforms like Heroku and Netlify. It's designed to simplify the deployment and management of applications, websites, and databases on your own infrastructure. With Coolify, you can deploy applications directly from Git repositories with just a few clicks.

Why Use Coolify?

Complete Control: You own your infrastructure and data
Cost-Effective: Eliminate ongoing SaaS subscription fees
Privacy: Your code and data stay on your servers
Customization: Configure everything to your exact needs
One-Click Deployments: Deploy applications straight from your Git repositories
Multiple Application Support: Host various applications, websites, and databases in one place

Prerequisites

Before installing Coolify, ensure your VPS meets these requirements:

At least 2 CPU cores
Minimum 4 GB RAM
40 GB storage
Ubuntu 20.04 or newer (Ubuntu 24.04 recommended)
Root or sudo access
SSH access
Internet connection
Basic understanding of Docker

Step-by-Step Installation Guide

Step 1: Connect to Your VPS

Connect to your server via SSH:

ssh root@your_server_ip

Step 2: Update Your System

Always start with a fully updated system:

apt update && apt upgrade -y

Step 3: Verify Docker Installation

Coolify requires Docker and Docker Compose. Check if Docker is already installed:

docker --version

If Docker isn't installed, follow the official Docker installation guide for your Ubuntu version from the Docker documentation.

Step 4: Install Coolify

The simplest way to install Coolify is using the official installation script:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash

Step 5: Access Coolify Dashboard

After installation completes successfully, the script will display your Coolify URL (typically http://your_server_ip:8000).
To access your dashboard:

Visit this URL in your web browser
You'll be redirected to a registration page
Create your first admin account immediately

Making Coolify Publicly Accessible

By default, Coolify might only be accessible locally. Let's configure it for public access.

Step 1: Configure Firewall Rules

First, check your firewall status:

sudo ufw status

If UFW isn't installed:

sudo apt install ufw

# Allow SSH
sudo ufw allow ssh

# Allow Coolify main port
sudo ufw allow 8000/tcp

# Allow HTTP and HTTPS for deployed applications
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

# Enable the firewall
sudo ufw enable

Step 2: Verify Port Binding

Ensure Coolify is listening on all interfaces:

sudo netstat -tulpn | grep 8000

You should see it bound to 0.0.0.0:8000 rather than just 127.0.0.1:8000.

Step 3: Restart Coolify

After making changes, restart Coolify:

cd /data/coolify/source
docker compose down
docker compose up -d

Step 4: Test External Access

Now try accessing Coolify from outside your server:

http://your-server-ip:8000

If you don't know your server's public IP address, use:

curl -4 icanhazip.com

Setting Up a Custom Domain for Your Coolify Dashboard

For a more professional setup, you can configure Coolify to use your own domain.

Step 1: Add DNS Record

First, add an A record at your domain registrar:

Type: A
Name: coolify (or subdomain of your choice, or @ for root domain)
Value: Your server's IP address

Step 2: Update Coolify Configuration
Modify Coolify's environment variables:

cd /data/coolify/source

# Backup existing environment file
cp .env .env.backup

# Edit the .env file
nano .env

Add or update these variables:

APP_URL=https://yourdomain.com
COOLIFY_FQDN=yourdomain.com

Step 3: Restart Coolify with New Configuration

cd /data/coolify/source

# Stop everything
docker compose --env-file .env -f docker-compose.yml -f docker-compose.prod.yml stop

# Start everything fresh
docker compose --env-file .env -f docker-compose.yml -f docker-compose.prod.yml up -d

Coolify should now be accessible via your custom domain!

Verifying Your Installation

To ensure everything is running properly:

1. Check Container Status:

docker ps

Look for Coolify-related containers running without errors.

2. Check Logs:

cd /data/coolify/source
docker compose logs

3. Test Dashboard Access:

Visit your dashboard URL (either IP:8000 or your custom domain) in a browser.

Conclusion

Coolify provides a powerful, self-hosted platform for managing your applications. By following this guide, you've successfully set up your own deployment platform that gives you complete control over your infrastructure.

With Coolify up and running, you can now deploy websites, applications, and databases with ease—all from a clean, user-friendly dashboard that you control.

Upcoming

explore more open-source technologies while solving real life problems.

Stay tuned and happy deploying!

Official documentation Coolify

How I Slashed Infrastructure Costs by 80% for a Struggling Startup

Jaskaran Deogan — Thu, 08 May 2025 20:18:15 +0000

When I took over a project for a client recently, I discovered they were spending nearly $1,000 monthly on AWS infrastructure despite having fewer than 5 active users. This is how I fixed it.

The Problem
I inherited: messy React frontend with 1000+ line components

Poorly designed Flask backend
Everything running in development mode on expensive AWS EC2 instances
A client who had just laid off their team and needed an MVP launched

The Solution
Instead of optimizing the existing AWS setup, I took a completely different approach:

Purchased two high-performance dedicated servers from Hetzner
Self-hosted Coolify as a Platform-as-a-Service solution
Containerized all application components
Implemented CICD with Github for streamlined deployments.
Migrated everything away from AWS

For those unfamiliar, Coolify is an open-source alternative to Netlify or Heroku that can be self-hosted on your own infrastructure.

The Results

80% reduction in monthly infrastructure costs (from ~$1,000 to ~$<200)
More stable environment with proper containerization
Simplified deployment process
Full control without vendor lock-in

Key Takeaway
Infrastructure decisions made early can dramatically impact your startup's runway. In this case, the original setup was burning cash that could have been better spent on product development or marketing.

Before automatically choosing the most popular cloud provider, consider alternatives like Hetzner combined with self-hosted PaaS solutions like Coolify. For many early-stage startups, this approach provides the right balance of developer experience and cost-efficiency.

Sometimes the best technical solution isn't the most expensive one.

Upcoming

Self-host Coolify on your own infrastructure
Host your own services like analytics, project management tools, interactive forms like Formspree, and much more.

Docker Advance: Mastering Containerization

Jaskaran Deogan — Thu, 08 May 2025 07:00:00 +0000

As an experienced developer, you're beyond the basics of docker run and docker build. You need to orchestrate complex, production-ready environments with precision. This guide dives deep into creating robust Docker deployments through YAML configurations, advanced networking, and container health management.

The Power of Docker Compose YAML

Docker Compose YAML files are the cornerstone of sophisticated multi-container applications. They provide a declarative way to define your entire infrastructure stack.

Anatomy of a Production Docker Compose File


services:
  api:
    build:
      context: ./backend
      dockerfile: Dockerfile.production
      args:
        - BUILD_ENV=production
    image: ${REGISTRY_URL}/myapp/api:${TAG:-latest}
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '0.50'
          memory: 512M
      restart_policy:
        condition: on-failure
        max_attempts: 3
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgres://user:pass@db:5432/app
    secrets:
      - api_key
    networks:
      - backend
      - frontend
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy

  db:
    image: postgres:14-alpine
    volumes:
      - db-data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
    environment:
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
    secrets:
      - db_password
    networks:
      - backend

  redis:
    image: redis:alpine
    command: ["redis-server", "--appendonly", "yes"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - redis-data:/data
    networks:
      - backend

  nginx:
    image: nginx:alpine
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certbot/conf:/etc/letsencrypt
      - ./certbot/www:/var/www/certbot
    ports:
      - "80:80"
      - "443:443"
    depends_on:
      - api
    networks:
      - frontend

volumes:
  db-data:
    driver: local
    driver_opts:
      type: 'none'
      o: 'bind'
      device: '/mnt/data/postgres'
  redis-data:
    driver: local

networks:
  frontend:
    driver: bridge
    ipam:
      config:
        - subnet: 172.16.238.0/24
  backend:
    driver: bridge
    internal: true
    ipam:
      config:
        - subnet: 172.16.239.0/24

secrets:
  api_key:
    file: ./secrets/api_key.txt
  db_password:
    file: ./secrets/db_password.txt

Key Configuration Components

Service Configuration

Build Context and Arguments

   build:
     context: ./backend
     dockerfile: Dockerfile.production
     args:
       - BUILD_ENV=production

This separates your build context from your Dockerfile location, allowing for complex build setups and parameterized builds.

Resource Limits

   deploy:
     resources:
       limits:
         cpus: '0.50'
         memory: 512M

Setting hard limits prevents container resource contention and protects your host system.

Health Checks - The Reliability Guardian

Health checks are critical for production readiness:

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
  interval: 30s
  timeout: 10s
  retries: 3
  start_period: 40s

This configuration:

Polls your service's health endpoint every 30 seconds
Allows 10 seconds for a response
Retries 3 times before marking unhealthy
Provides a 40-second grace period during startup

Health checks enable:

Self-healing containers that restart when services fail
Dependency ordering based on actual service readiness
Orchestration-level service discovery

Networking - Isolated and Secure

networks:
  frontend:
    driver: bridge
    ipam:
      config:
        - subnet: 172.16.238.0/24
  backend:
    driver: bridge
    internal: true
    ipam:
      config:
        - subnet: 172.16.239.0/24

The internal: true flag for the backend network is crucial - it prevents any container in this network from establishing outbound connections to the internet, creating a security boundary.

Advanced Docker Image Configuration

Multi-stage Builds for Production Efficiency

# Build stage
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine
WORKDIR /app
ENV NODE_ENV production
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./

# Use non-root user for security
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nodejs -u 1001 && \
    chown -R nodejs:nodejs /app
USER nodejs

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

# Runtime configuration
EXPOSE 3000
CMD ["node", "dist/main.js"]

The Importance of Base Image Selection

Base image selection dramatically impacts security, size, and performance:

Distroless Images: Contain only your application and its runtime dependencies
Alpine Variants: Minimal footprint but include package managers for flexibility
Scratch Images: Empty images for compiled languages, offering the smallest attack surface

Compare the image size differences:

Node on Debian: ~900MB
Node on Alpine: ~170MB
Go compiled binary on scratch: ~10MB

Volume Management - Data Persistence Done Right

volumes:
  db-data:
    driver: local
    driver_opts:
      type: 'none'
      o: 'bind'
      device: '/mnt/data/postgres'

This configuration maps container data to specific host locations with precise mounting options, ensuring data integrity across container lifecycles.

Secrets Management - The Secure Way

secrets:
  api_key:
    file: ./secrets/api_key.txt

Secrets in Docker Compose are mounted as files, not environment variables, preventing credential leakage in process lists or error logs.

Network Design Principles

Creating Defense-in-Depth

Least Privilege Networking:
- Frontend-facing services in one network
- Backend services in an internal network
- Database in its own isolated network
Network Segmentation Benefits:
- Limits attack vectors if perimeter is breached
- Provides clear traffic flow visibility
- Enables granular firewall rules

Custom Bridge Networks with Static IPs

networks:
  app_net:
    driver: bridge
    ipam:
      driver: default
      config:
        - subnet: 172.28.0.0/16
          ip_range: 172.28.5.0/24
          gateway: 172.28.5.254

Static IP assignments allow for deterministic network configurations, especially useful when integrating with legacy systems or configuring static firewall rules.

Container Dependency Management

depends_on:
  db:
    condition: service_healthy
  redis:
    condition: service_healthy

This ensures your application only starts when its dependencies are truly ready to accept connections, not just when their containers have started.

Why This Advanced Approach Matters

Infrastructure as Code: Your entire environment is versioned, reproducible, and testable
Consistency Across Environments: Dev, staging, and production use identical configurations
Security by Design: Network isolation, minimal base images, and proper secret management
Simplified Disaster Recovery: Rebuild your entire stack with a single command
Efficient Resource Utilization: Precise resource limits prevent waste and contention

Moving Beyond Basic Docker

When working at scale, consider these advanced patterns:

Configuration Management with Docker Configs

configs:
  nginx_config:
    file: ./nginx.conf

Unlike volumes, configs are immutable and better represent configuration as code.

Custom Health Check Implementations

For complex applications, implement sophisticated health checks that verify:

Database connections
External API availability
Cache system functionality
Queue processor status

Init Systems and Zombie Process Prevention

services:
  app:
    init: true

The init: true flag adds a lightweight init system to your container, preventing zombie processes and ensuring proper signal handling.

The Path to Orchestration

This advanced Docker Compose setup forms the foundation for moving to orchestration platforms like Kubernetes. The principles remain the same:

Declarative configuration
Health monitoring
Resource management
Network segmentation
Secret handling

By mastering these Docker concepts, you're not just containerizing applications—you're building production-ready, scalable, and secure systems that embody DevOps best practices.

The true power of Docker isn't in simplifying development; it's in enabling consistent, repeatable infrastructure that bridges the gap between development and operations, turning the art of deployment into a precise science.

Upcoming

How to self-host Coolify - an open source alternative to Netlify or Heroku.
self-host services like analytics, email-server, interactive-forms, databases and much more!

What is Docker and Why Should You Care?

Jaskaran Deogan — Tue, 06 May 2025 20:39:39 +0000

Look, I get it. When I started out 3 years ago, I was all about getting my apps online the quickest way possible. Vercel for my Next.js projects, Netlify for static sites, and PM2 to keep my Node.js apps running on that cheap VPS I rented. It worked... until it didn't.

If you're like me, I highly encourage you to explore about Docker.

The Deployment Methods I Used to Swear By

I thought I had it all figured out:

The One-Click Wonder: Push to GitHub, automatic deployment to a hosting platform. Magic! Until I needed custom environment configurations or hit the free tier limits.
The PM2 Savior: SSH into my server, git pull, npm install, pm2 restart. Simple enough... except when dependencies broke, or node versions mismatched, or any of the other thousand things that could go wrong.
The "It's Working, Don't Touch It" Server: That Ubuntu VPS running four different apps with a tangled mess of nginx configurations. Heaven forbid I needed to update anything!

Why It All Started Breaking Down

As my projects grew, the cracks started showing:

Dependency Hell: "Works on my machine" became my catchphrase.
Configuration Nightmares: Each service had its own way of setting environment variables.
Budget Stress: Free tiers ran out fast, and suddenly I was paying $50+ monthly for basic hosting.
Scaling Issues: Adding new features meant fighting with deployment configurations.
Popular Blunders: I was once told by someone in the industry how their aws bill went up to 100k USD while their product was still in development. I also experienced myself with AWS where their elastic compute is just out of control. Someone new to this tech is bound to make mistakes which can result in huge loss for the company or you.

Docker: The Game-Changer

It's so powerful. You can run multiple containers on the same server/device just like that.

1. Environment Consistency

No more "but it works on my machine" moments. Docker ensures my app runs the same way everywhere. Everything my app needs is defined in a Dockerfile:

FROM node:18-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

2. Portable Development

I can now share my entire development setup with a teammate by sending them a single file. No more "First install Node 16, then PostgreSQL 13, then configure this environment variable..."

3. Local Testing That Actually Matches Production

With Docker, I test in an environment identical to production. No more "it worked in development" problems.

4. Freedom From Provider Lock-in

Before, switching hosting providers meant learning a whole new deployment process. Now, I can take my containerized app anywhere that runs Docker.

System Requirements - What You Need

For Local Development:

Component	Minimum Requirements	Recommended
CPU	2 cores	4+ cores
RAM	4GB	8GB+
Disk Space	10GB free	20GB+ free
OS	Windows 10+, macOS 10.15+, Linux with kernel 3.10+	Latest versions
Docker Installation	Docker Desktop or Docker Engine	Latest stable version

For Cloud Deployment:

Resource	Minimum	Recommended
CPU	1 shared core	2+ dedicated cores
RAM	512MB	2GB+
Storage	5GB	20GB+
Bandwidth	1GB/month	100GB+/month
Docker	Docker Engine 20.10+	Latest version

How I Migrated My Next.js App to Docker

Switching was surprisingly easy:

Step 1: Create a Dockerfile

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./
RUN npm install

COPY . .
RUN npm run build

EXPOSE 3000

CMD ["npm", "start"]

Step 2: Add a .dockerignore File

node_modules
.next
.git

Step 3: Build and Run My Container

# Build the Docker image
docker build -t my-nextjs-app .

# Run the container
docker run -p 3000:3000 my-nextjs-app

Just like that, my app was running in a consistent, portable environment.

How I Saved Money

The biggest revelation was realizing I could replace multiple paid services with self-hosted alternatives:

Database Costs: Instead of paying for a managed database, I run PostgreSQL in a container.
Multiple Projects: I can host several Docker containers on a single affordable VPS instead of paying per-project.
Form Handling: No need for form submission services when I can run a simple form-handling self-hosted service in a container.
Analytics: Replaced paid analytics with a self-hosted open-source solution.

The "I Wish Someone Told Me This Sooner" Moment

Looking back, I wasted so much time fighting with deployment issues that Docker would have solved instantly. If you're still manually SSHing into servers or hitting the limits of one-click deploys, do yourself a favor and spend a day learning Docker.

The knowledge transfers everywhere, works for any programming language or framework, and will save you countless hours of debugging environment-specific issues.

Docker isn't just another tool in your stack—it's a completely different approach to development and deployment that makes everything else easier.

Are you still using PM2 and praying your server doesn't crash? Still hitting free tier limits on deployment platforms? It might be time to containerize your way to developer happiness.

Supercharge Your UI Development with Storybook

Jaskaran Deogan — Sun, 19 Mar 2023 20:06:57 +0000

"Storybook for Component-Driven Development: A Comprehensive Guide" - Learn how Storybook simplifies UI component development by allowing developers to view and interact with components in isolation. Discover the benefits of using Storybook to document component-driven development and get started with it today.

Why Storybook is Useful for Documenting Component-Driven Development
Storybook is valuable for documenting components in a clear and accessible way. It's especially helpful for large-scale projects with multiple developers. Teams can create their own stories to review each other's work and catch errors early on. It also helps improve code quality by isolating and testing components in various states. This reduces debugging time and enhances the overall stability of the application.

How to Get Started with Storybook
Getting started with Storybook is relatively easy. Here are the basic steps:

Install Storybook using your preferred package manager. For example, you can use the following command with npm:

npm install -D @storybook/react

Create a configuration file for Storybook. You can use the following command to create a basic configuration file:

npx sb init

Note: depending upon your styling, you may have to configure this further. check official documentation

Create your first story. You can create a new file in your project's src directory. Here is a small demo how I created a story of one of my component.

src/components/ProgressBar/ProgressBar.stories.js. Here's an example of what the file might look like:

import React from "react";
import { Meta, Story } from "@storybook/react";
import CircularProgressBar from "../components/CircularProgressBar";
import { CircularProgressBarProps } from "@/types/components";

export default {
  title: "Components/CircularProgressBar",
  component: CircularProgressBar,
  layout: "fullscreen",
} as Meta;

const Template: Story<CircularProgressBarProps> = (args) => (
  <CircularProgressBar {...args} />
);

export const Default = Template.bind({});
Default.args = {
  children: (
    <div className="flex items-center justify-center text-lg font-bold text-gray-700 rounded-full bg-white h-20 w-20 ">
      75%
    </div>
  ),
};

export const CustomColors = Template.bind({});
CustomColors.args = {
  progressStart: 50,
  progressEnd: 100,
  barColor: "#10B981",
  className: "bg-gray-200",
  children: (
    <div className="flex items-center justify-center text-lg font-bold text-gray-700 rounded-full bg-slate-400 h-20 w-20">
      75%
    </div>
  ),
};

export const SlowSpeed = Template.bind({});
SlowSpeed.args = {
  progressStart: 0,
  progressEnd: 90,
  speed: 50,
  barColor: "#F59E0B",
  children: (
    <div className="flex items-center justify-center text-lg font-bold text-gray-700 rounded-full bg-slate-400 h-20 w-20">
      {}
    </div>
  ),
};

This example creates a story for a ProgressBar that wraps a child and show a progress. component has been shown three different states default, custom color and custom speed.

Start the Storybook server. You can use the following command:

npm run storybook

This will start the Storybook

A screenshot of storybook dashboard, and how you can customise component with props.