n8n Tutorial: From Basic Workflows to Deployment

Ever wished you could automate tedious tasks without writing endless lines of code or relying on expensive, proprietary platforms? Enter n8n! 🚀

n8n (pronounced “n-eight-n”) is a powerful, open-source workflow automation tool that lets you connect various apps and services to automate your daily operations. Whether it’s managing your CRM, sending automated emails, updating spreadsheets, or posting to social media, n8n empowers you to build complex workflows with a visual, low-code interface.

This comprehensive guide will walk you through the journey of using n8n, from understanding its core concepts and building your very first basic workflow to exploring advanced features and deploying it for production use. Let’s dive in!

1. What is n8n and Why Choose It? 🤔

n8n is a “fair-code” licensed workflow automation platform. Unlike many cloud-based integration platforms as a service (iPaaS), n8n gives you the flexibility to self-host, ensuring greater control over your data and infrastructure.

Why n8n Stands Out:

• Open-Source & Self-Hostable: 🛡️ Complete control over your data and privacy. You can run it on your own server, cloud, or even locally.
• Extensive Integrations: Connects with hundreds of apps like Slack, Google Sheets, Salesforce, Mailchimp, custom APIs, and more. 🔗
• Low-Code/No-Code Flexibility: Build powerful workflows using a drag-and-drop interface, but also allows JavaScript for complex logic when needed. ✍️
• Scalability: Designed to handle simple tasks to complex enterprise-level automations. 🚀
• Fair-Code Licensing: It balances the benefits of open-source with a sustainable business model, meaning core functionalities are always accessible.

2. Getting Started: Installation & Setup ⚙️

The easiest way to get n8n up and running for local development or testing is using Docker.

2.1. Prerequisites:

• Docker Desktop: Make sure Docker is installed and running on your system.
  • Download Docker Desktop

2.2. Installation via Docker:

1. Create a Directory: Choose a location for your n8n data.

   mkdir ~/.n8n

2. Run the Docker Container:

   docker run -it --rm \
       --name n8n \
       -p 5678:5678 \
       -v ~/.n8n:/home/node/.n8n \
       n8n

   • --name n8n: Gives your container a memorable name.
   • -p 5678:5678: Maps port 5678 on your host machine to port 5678 inside the container (n8n’s default port).
   • -v ~/.n8n:/home/node/.n8n: Mounts a volume to persist your workflow data, credentials, and settings. This is crucial so you don’t lose your work when the container stops.
   • n8n: The Docker image name.

3. Access n8n: Open your web browser and navigate to http://localhost:5678.

   • You’ll be prompted to create your first user account. This will be your admin user for n8n.

Other Installation Methods:

• npm/yarn: For local development or integrating into an existing Node.js project.

  npm install n8n -g
  n8n start

• Cloud Hosting: n8n offers a n8n Cloud managed service for those who prefer not to self-host. Many users also deploy to VPS providers like DigitalOcean, AWS EC2, or Google Cloud.

3. Core Concepts of n8n Workflows 💡

Before building, let’s understand the fundamental building blocks:

• Workflows: 🔄 A sequence of connected nodes that perform a specific automated task.
• Nodes: ⚙️ Individual blocks that perform a specific action (e.g., trigger an event, send an email, get data from an API). Nodes are categorized:
  • Trigger Nodes: Start a workflow (e.g., Webhook, Cron, RSS Feed, New Record in Salesforce).
  • Regular Nodes: Perform actions or manipulate data within a workflow (e.g., Send Email, HTTP Request, Set, If, Code).
• Connections: 🔗 Arrows that link nodes, determining the flow of data from one node’s output to another node’s input.
• Executions: 🏃 An instance of a workflow running. You can view execution history, success/failure status, and data that flowed through each node.
• Credentials: 🔑 Securely store authentication details (API keys, usernames, passwords) for various services.

4. Part 1: Building Your First Basic Workflow (Email Automation) 📧

Let’s create a simple workflow: When a specific webhook is triggered, n8n will send an email.

Workflow Goal:

Webhook Trigger -> Send Email

Steps:

1. Create a New Workflow:

   • In the n8n UI, click “New” or the “+” icon to start a fresh workflow.

2. Add a Webhook Trigger Node:

   • Click the “Add first node” button or the “+” icon in the canvas.
   • Search for “Webhook” and select the Webhook node under “Triggers.”
   • In the Webhook node’s settings panel:
     • Mode: Keep “Regular.”
     • HTTP Method: Keep “GET” (for simplicity, but POST is common for real data).
     • Authentication: “None” for this example.
   • Click “Execute Workflow” (or “Listen for test event” in older versions) to activate the test URL. Copy the “Test URL” that appears. This URL is unique to your workflow.
     • Tip: Open this URL in your browser or use a tool like Postman to trigger it. When you do, the Webhook node will show “webhook received” or similar feedback.

3. Add an Email Node:

   • Click the “+” button to the right of the Webhook node to add a new node.
   • Search for “Email” and select the Email Send node.
   • In the Email Send node’s settings panel:
     • Authentication: You’ll need to set up credentials.
       • Select “Create New Credential.”
       • Choose your email service (e.g., “SMTP,” “Gmail API,” “SendGrid API”). For basic SMTP:
         • Host: Your SMTP server (e.g., smtp.gmail.com for Gmail, smtp.mail.yahoo.com for Yahoo).
         • Port: Usually 587 (TLS) or 465 (SSL).
         • Secure: Check this box for TLS/SSL.
         • User: Your email address.
         • Password: Your email account password or an app-specific password (highly recommended for Gmail and other services).
       • Click “Save.”
     • To: Enter the recipient’s email address (e.g., your_email@example.com).
     • From: Your email address (must match the one used for credentials).
     • Subject: “Hello from n8n! 👋”
     • Text: “This is your first automated email from an n8n workflow!”
   • Pro Tip: You can use data from previous nodes! For example, if your webhook received a name parameter, you could set the subject to Hello from n8n, {{ $json.name }}!.

4. Connect the Nodes:

   • The Webhook node should automatically be connected to the Email Send node when you add it sequentially. If not, drag a line from the output handle of the Webhook node to the input handle of the Email Send node.

5. Test the Workflow:

   • Click “Execute Workflow” in the top right corner.
   • Go back to your browser (or Postman) and trigger the Test URL you copied from the Webhook node.
   • Watch the n8n canvas: you should see a green checkmark on both nodes, indicating success. Check your inbox for the email! 📬

6. Activate the Workflow:

   • Once you’re satisfied with your test, toggle the “Active” switch in the top right corner of the n8n UI. This makes your workflow live and enables the “Production URL” for the webhook (which you should use for real-world scenarios).

Congratulations! You’ve just built and tested your first n8n workflow. 🎉

5. Part 2: Advanced Workflow Concepts & Practical Examples 📈

Basic workflows are just the beginning. Let’s explore more powerful concepts and practical use cases.

5.1. Key Advanced Concepts:

• Data Manipulation (Set Node, Code Node):
  • Set Node: Used to add, modify, or remove data fields. Perfect for structuring data before sending it to another service.
    • Example: Set a fullName field by combining firstName and lastName.
  • Code Node: For complex logic that standard nodes can’t handle. Write JavaScript code to transform data, make custom calculations, or call external functions.
    • Example: Calculate tax based on a price and region.
• Conditional Logic (If Node):
  • If Node: Allows branching your workflow based on conditions. For instance, send different emails based on a user’s subscription status.
    • Example: If (order.total > 100) -> Apply Discount, Else -> Send Regular Confirmation.
• Looping & Batch Processing (Split In Batches Node):
  • If a previous node outputs a list of items (e.g., 100 contacts from a CRM), Split In Batches lets you process them one by one or in smaller groups to avoid API rate limits or process individual items.
• Error Handling (Try/Catch Block):
  • Wrap a section of your workflow with Try/Catch nodes to gracefully handle errors, preventing the entire workflow from failing. You can log errors, send notifications, or retry operations.

5.2. Practical Examples:

Example 1: Automating Lead Nurturing & Notification 📊

Goal: When a new lead is added to your CRM, add them to a mailing list, send a welcome email, and notify your sales team on Slack.

Workflow Flow: CRM Trigger (e.g., HubSpot, Salesforce) -> Get Lead Details -> If (Lead Status == "New") -> TRUE branch: -> Mailchimp (Add Contact) -> Gmail Send (Welcome Email) -> Slack (New Lead Notification) -> FALSE branch: -> End Workflow

Nodes Involved:

• CRM Trigger Node: (e.g., HubSpot Trigger – “New Contact Created”)
• CRM Node: (e.g., HubSpot – “Get a Contact” to fetch full details)
• If Node: To check the lead’s status or source.
• Mailchimp Node: To subscribe the contact to a specific list.
• Gmail Send Node: To send a personalized welcome email using data from the CRM.
• Slack Node: To send a message to a sales channel with lead details.

How it works:

1. The CRM trigger fires when a new contact is created.
2. n8n fetches detailed information about the new contact.
3. The If node checks a condition (e.g., {{ $json.status == "New" }}).
4. If true, the workflow proceeds to add the contact to Mailchimp, send an email, and post a Slack message.
5. If false, the workflow simply ends.

Example 2: Content Repurposing with AI ✍️💬

Goal: Monitor an RSS feed for new articles, use an AI service to summarize them, and then automatically post the summary to Twitter.

Workflow Flow: RSS Feed Trigger -> HTTP Request (to OpenAI API for summarization) -> Set (Format Summary) -> Twitter (Create Tweet)

Nodes Involved:

• RSS Feed Trigger: Monitors a blog’s RSS feed for new items.
• HTTP Request Node:
  • Method: POST
  • URL: OpenAI API endpoint (e.g., https://api.openai.com/v1/chat/completions)
  • Headers: Authorization: Bearer YOUR_OPENAI_API_KEY
  • Body: JSON payload containing the article content and a prompt for summarization (e.g., Please summarize the following text: {{ $json.item.content }}).
• Set Node: To extract the summary from the OpenAI response and potentially truncate it to fit Twitter’s character limit.
• Twitter Node: To create a new tweet. You would map the summarized text from the Set node to the “Text” field.

How it works:

1. The RSS Feed node detects a new article.
2. The content of the new article is sent to the OpenAI API.
3. OpenAI returns a summarized version of the article.
4. The Set node cleans up and formats the summary.
5. The Twitter node posts the formatted summary as a tweet.

6. Part 3: Deployment Options for Production ☁️💻

For a production environment, simply running docker run isn’t enough. You need to ensure persistence, uptime, and proper configuration.

6.1. Self-Hosting with Docker Compose (Recommended for most)

Docker Compose is ideal for defining and running multi-container Docker applications. It simplifies the setup of n8n with a persistent database (like PostgreSQL) and ensures proper restart policies.

Example docker-compose.yml (simplified):

version: '3.8'

services:
  n8n:
    image: n8n:latest
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=${N8N_HOST} # Your domain name (e.g., my.n8n.app)
      - N8N_PORT=5678
      - N8N_PROTOCOL=https # Use https for production
      - WEBHOOK_URL=${WEBHOOK_URL} # Your webhook base URL
      - GENERIC_TIMEZONE=Europe/Berlin # Or your timezone
      - TZ=Europe/Berlin # Or your timezone
      - N8N_BASIC_AUTH_ACTIVE=true # Enable basic auth for UI
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      # Database connection (if not using SQLite, recommended for production)
      # - DB_TYPE=postgresdb
      # - DB_POSTGRESDB_HOST=postgres
      # - DB_POSTGRESDB_DATABASE=n8n
      # - DB_POSTGRESDB_USER=n8n
      # - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
    volumes:
      - ${DATA_FOLDER:-./.n8n}:/home/node/.n8n
    # depends_on: # Uncomment if using external DB like postgres
    #   - postgres

  # Optional: PostgreSQL database (uncomment if you need a dedicated DB)
  # postgres:
  #   image: postgres:13
  #   restart: always
  #   environment:
  #     - POSTGRES_DB=n8n
  #     - POSTGRES_USER=n8n
  #     - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
  #   volumes:
  #     - postgres_data:/var/lib/postgresql/data

# volumes: # Uncomment if using external DB
#   postgres_data:

1. Save: Save this as docker-compose.yml in a directory (e.g., ~/n8n-production).
2. Environment Variables: Create a .env file in the same directory to define your variables:

   N8N_HOST=your.domain.com
   WEBHOOK_URL=https://your.domain.com/
   N8N_USER=admin
   N8N_PASSWORD=your_secure_password
   # POSTGRES_PASSWORD=your_db_password
   DATA_FOLDER=./.n8n

3. Run: Navigate to the directory in your terminal and run:

   docker-compose up -d

   This will pull images, create containers, and run them in the background.

Considerations for Production Self-Hosting:

• Reverse Proxy (Nginx/Caddy): Essential for HTTPS (SSL certificates) and managing multiple domains. It sits in front of n8n (port 5678) and forwards traffic.
• Persistent Storage: Always use Docker volumes or bind mounts (-v) for your n8n data and database to prevent data loss.
• Database: For production, move away from SQLite (default) to PostgreSQL or MySQL for better performance, concurrency, and reliability.
• Security:
  • Enable basic authentication for the n8n UI.
  • Use strong, unique passwords and API keys.
  • Keep n8n updated.
  • Implement firewalls.
• Monitoring & Logging: Set up tools to monitor n8n’s health and performance, and centralize logs.
• Backups: Regularly back up your n8n data folder and database.

6.2. Managed Cloud Providers (PaaS)

For those who want less infrastructure management overhead:

• n8n Cloud: The official managed service by n8n. Simplest option, zero setup required from your end. Ideal for teams that want to focus solely on building workflows.
• Heroku/Render: Platform-as-a-Service providers where you can deploy n8n containers. They handle much of the underlying infrastructure, scaling, and maintenance. You’ll still need to configure environment variables and possibly a persistent database addon.

7. Best Practices for n8n Workflows ✅

To ensure your automations are robust, maintainable, and efficient:

• Modularize Your Workflows: Break down complex tasks into smaller, manageable sub-workflows. You can call one workflow from another using the Execute Workflow node.
• Implement Error Handling: Use Try/Catch blocks for critical parts of your workflow. Define what happens if an error occurs (e.g., send a notification, log the error, retry).
• Use Descriptive Naming: Give meaningful names to your workflows, nodes, and credentials. This helps immensely when debugging or revisiting old automations.
• Leverage Credentials Securely: Always store sensitive information (API keys, passwords) in n8n’s secure Credential Store, never directly in nodes.
• Test Thoroughly: Use the “Execute Workflow” button to test individual nodes or the entire flow frequently during development. Use the “Test URL” for webhooks.
• Monitor Executions: Regularly check the “Executions” tab to ensure your workflows are running as expected and to identify any failures.
• Add Comments: Use the Note node to add explanations or context to complex parts of your workflow. Your future self (or teammates) will thank you!
• Version Control (Optional but Recommended): For critical workflows, consider exporting them as JSON and storing them in a Git repository.
• Consider Rate Limits: Be mindful of API rate limits of the services you’re connecting to. Use the Wait node or Split In Batches with delays to avoid hitting limits.

Conclusion ✨

n8n is a game-changer for anyone looking to automate their digital life or business processes. From simple email automations to complex lead management systems, its visual interface, extensive integrations, and open-source nature make it an incredibly versatile and powerful tool.

You’ve learned the basics of setting up n8n, built your first workflow, explored advanced concepts like data manipulation and conditional logic, and understood the different deployment strategies for production.

The best way to master n8n is to experiment! Think about a repetitive task you do daily or weekly, and try to automate it with n8n. The possibilities are truly endless. Happy automating! 🚀🤖 G