📧 Email Services: Nodemailer Setup

🎯 Introduction

Welcome to this exciting tutorial on email services with Nodemailer! 📧 In this guide, we’ll explore how to send emails programmatically using TypeScript and the powerful Nodemailer library.

You’ll discover how email services can transform your applications - from user notifications 📬, account verification 🔐, to marketing campaigns 📈. Whether you’re building web applications 🌐, server-side APIs 🖥️, or automated systems 🤖, understanding email integration is essential for modern development.

By the end of this tutorial, you’ll feel confident implementing email services in your TypeScript projects! Let’s dive in! 🏊‍♂️

📚 Understanding Email Services

🤔 What is Nodemailer?

Nodemailer is like having your own personal mail carrier 📮 for your applications. Think of it as a digital postman that can send emails from your code to anyone in the world!

In TypeScript terms, Nodemailer provides a type-safe way to handle email delivery 📧. This means you can:

✨ Send professional emails programmatically
🚀 Handle attachments and HTML content
🛡️ Use secure authentication methods
📊 Track email delivery status

💡 Why Use Nodemailer?

Here’s why developers love Nodemailer:

Type Safety 🔒: Full TypeScript support with proper typing
Multiple Providers 💻: Works with Gmail, Outlook, SendGrid, and more
Rich Features 📖: Attachments, HTML emails, templates
Reliability 🔧: Robust error handling and retry mechanisms

Real-world example: Imagine building an e-commerce site 🛒. With Nodemailer, you can send order confirmations, shipping updates, and promotional emails automatically!

🔧 Basic Syntax and Usage

📝 Installation and Setup

Let’s start by setting up our project:

# 📦 Install dependencies
npm install nodemailer
npm install -D @types/nodemailer

# ⚡ Or with pnpm
pnpm add nodemailer
pnpm add -D @types/nodemailer

🎯 Basic Configuration

Here’s your first email service setup:

// 📧 Basic email service setup
import nodemailer from 'nodemailer';

// 🔧 Email configuration interface
interface EmailConfig {
  host: string;
  port: number;     // 📫 Mail server port
  secure: boolean;  // 🔒 Use SSL/TLS
  auth: {
    user: string;   // 👤 Your email
    pass: string;   // 🗝️ Your password (use app passwords!)
  };
}

// 🎨 Creating a transporter
const emailConfig: EmailConfig = {
  host: 'smtp.gmail.com',
  port: 587,
  secure: false, // 🔓 Use STARTTLS
  auth: {
    user: '[email protected]',
    pass: 'your-app-password' // ⚠️ Never hardcode this!
  }
};

const transporter = nodemailer.createTransporter(emailConfig);

💡 Pro Tip: Always use environment variables for sensitive data like passwords!

🎮 Simple Email Example

// 📬 Email message interface
interface EmailMessage {
  from: string;       // 👤 Sender
  to: string | string[]; // 📮 Recipients
  subject: string;    // 📝 Email subject
  text?: string;      // 📄 Plain text
  html?: string;      // 🎨 HTML content
  attachments?: any[]; // 📎 File attachments
}

// ✉️ Send a simple email
async function sendWelcomeEmail(userEmail: string, userName: string): Promise<void> {
  const message: EmailMessage = {
    from: '"Welcome Team 👋" <[email protected]>',
    to: userEmail,
    subject: `Welcome to our app, ${userName}! 🎉`,
    html: `
      <div style="font-family: Arial, sans-serif; max-width: 600px;">
        <h2>Welcome ${userName}! 🎉</h2>
        <p>We're excited to have you join our community! 🚀</p>
        <p>Get started by exploring these features:</p>
        <ul>
          <li>📊 Dashboard analytics</li>
          <li>🛠️ Project management tools</li>
          <li>👥 Team collaboration</li>
        </ul>
        <p>Happy coding! 💻✨</p>
      </div>
    `
  };

  try {
    const info = await transporter.sendMail(message);
    console.log('📧 Email sent successfully!', info.messageId);
  } catch (error) {
    console.error('❌ Failed to send email:', error);
    throw error;
  }
}

💡 Practical Examples

🛒 Example 1: E-commerce Order Confirmation

Let’s build a real e-commerce email system:

// 🛍️ Order and product interfaces
interface Product {
  id: string;
  name: string;
  price: number;
  quantity: number;
  emoji: string;
}

interface Order {
  id: string;
  customerName: string;
  customerEmail: string;
  products: Product[];
  totalAmount: number;
  orderDate: Date;
  shippingAddress: string;
}

// 📧 E-commerce email service
class ECommerceEmailService {
  private transporter: nodemailer.Transporter;

  constructor(config: EmailConfig) {
    this.transporter = nodemailer.createTransporter(config);
  }

  // 📦 Send order confirmation
  async sendOrderConfirmation(order: Order): Promise<void> {
    const productsHtml = order.products
      .map(product => `
        <tr>
          <td>${product.emoji} ${product.name}</td>
          <td>${product.quantity}</td>
          <td>$${product.price.toFixed(2)}</td>
          <td>$${(product.price * product.quantity).toFixed(2)}</td>
        </tr>
      `).join('');

    const emailHtml = `
      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
        <h2>🎉 Order Confirmation #${order.id}</h2>
        <p>Hi ${order.customerName},</p>
        <p>Thanks for your order! Here are the details:</p>
        
        <table style="width: 100%; border-collapse: collapse; margin: 20px 0;">
          <thead>
            <tr style="background-color: #f5f5f5;">
              <th style="padding: 10px; border: 1px solid #ddd;">Product</th>
              <th style="padding: 10px; border: 1px solid #ddd;">Qty</th>
              <th style="padding: 10px; border: 1px solid #ddd;">Price</th>
              <th style="padding: 10px; border: 1px solid #ddd;">Total</th>
            </tr>
          </thead>
          <tbody>
            ${productsHtml}
          </tbody>
        </table>
        
        <div style="background-color: #f9f9f9; padding: 15px; margin: 20px 0;">
          <h3>📋 Order Summary</h3>
          <p><strong>Total Amount: $${order.totalAmount.toFixed(2)}</strong></p>
          <p><strong>Order Date:</strong> ${order.orderDate.toLocaleDateString()}</p>
          <p><strong>Shipping Address:</strong> ${order.shippingAddress}</p>
        </div>
        
        <p>We'll send you a shipping confirmation once your order is on its way! 🚚</p>
        <p>Happy shopping! 🛒✨</p>
      </div>
    `;

    await this.transporter.sendMail({
      from: '"ShopMaster 🛒" <[email protected]>',
      to: order.customerEmail,
      subject: `Order Confirmation #${order.id} 📦`,
      html: emailHtml
    });

    console.log(`✅ Order confirmation sent to ${order.customerEmail}`);
  }

  // 🚚 Send shipping notification
  async sendShippingNotification(order: Order, trackingNumber: string): Promise<void> {
    const emailHtml = `
      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
        <h2>🚚 Your Order is on the Way!</h2>
        <p>Hi ${order.customerName},</p>
        <p>Great news! Your order #${order.id} has been shipped and is on its way to you! 📦</p>
        
        <div style="background-color: #e8f5e8; padding: 20px; margin: 20px 0; border-radius: 8px;">
          <h3>📍 Tracking Information</h3>
          <p><strong>Tracking Number:</strong> <code>${trackingNumber}</code></p>
          <p><strong>Estimated Delivery:</strong> 3-5 business days 📅</p>
        </div>
        
        <p>You can track your package using the tracking number above. 🔍</p>
        <p>Thanks for shopping with us! 🙏</p>
      </div>
    `;

    await this.transporter.sendMail({
      from: '"ShipMaster 🚚" <[email protected]>',
      to: order.customerEmail,
      subject: `📦 Your order #${order.id} is shipped!`,
      html: emailHtml
    });

    console.log(`🚚 Shipping notification sent to ${order.customerEmail}`);
  }
}

🎮 Example 2: User Authentication System

Let’s create an authentication email service:

// 🔐 Authentication email service
class AuthEmailService {
  private transporter: nodemailer.Transporter;
  private baseUrl: string;

  constructor(config: EmailConfig, baseUrl: string) {
    this.transporter = nodemailer.createTransporter(config);
    this.baseUrl = baseUrl;
  }

  // ✉️ Send verification email
  async sendVerificationEmail(email: string, token: string): Promise<void> {
    const verificationUrl = `${this.baseUrl}/verify-email?token=${token}`;
    
    const emailHtml = `
      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
        <h2>🔐 Verify Your Email Address</h2>
        <p>Welcome! Please click the button below to verify your email address:</p>
        
        <div style="text-align: center; margin: 30px 0;">
          <a href="${verificationUrl}" 
             style="background-color: #007bff; color: white; padding: 12px 24px; 
                    text-decoration: none; border-radius: 6px; display: inline-block;">
            ✅ Verify Email Address
          </a>
        </div>
        
        <p>Or copy and paste this link into your browser:</p>
        <p style="word-break: break-all; color: #666;">
          ${verificationUrl}
        </p>
        
        <div style="background-color: #fff3cd; padding: 15px; margin: 20px 0; border-radius: 6px;">
          <p><strong>⚠️ Important:</strong> This link will expire in 24 hours for security.</p>
        </div>
        
        <p>If you didn't create this account, please ignore this email. 🤷‍♂️</p>
      </div>
    `;

    await this.transporter.sendMail({
      from: '"SecureApp 🔒" <[email protected]>',
      to: email,
      subject: '🔐 Please verify your email address',
      html: emailHtml
    });

    console.log(`📧 Verification email sent to ${email}`);
  }

  // 🔄 Send password reset email
  async sendPasswordResetEmail(email: string, resetToken: string): Promise<void> {
    const resetUrl = `${this.baseUrl}/reset-password?token=${resetToken}`;
    
    const emailHtml = `
      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
        <h2>🔑 Password Reset Request</h2>
        <p>We received a request to reset your password. Click the button below to create a new password:</p>
        
        <div style="text-align: center; margin: 30px 0;">
          <a href="${resetUrl}" 
             style="background-color: #dc3545; color: white; padding: 12px 24px; 
                    text-decoration: none; border-radius: 6px; display: inline-block;">
            🔑 Reset Password
          </a>
        </div>
        
        <div style="background-color: #f8d7da; padding: 15px; margin: 20px 0; border-radius: 6px;">
          <p><strong>🚨 Security Notice:</strong></p>
          <ul>
            <li>This link expires in 1 hour ⏰</li>
            <li>Only use this if you requested it 🛡️</li>
            <li>Never share this link with anyone 🤫</li>
          </ul>
        </div>
        
        <p>If you didn't request this, please ignore this email and your password will remain unchanged. 🔒</p>
      </div>
    `;

    await this.transporter.sendMail({
      from: '"SecureApp 🔒" <[email protected]>',
      to: email,
      subject: '🔑 Password Reset Request',
      html: emailHtml
    });

    console.log(`🔑 Password reset email sent to ${email}`);
  }
}

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Email Templates with Handlebars

When you’re ready to level up, try template engines:

// 🎨 Advanced email template system
import handlebars from 'handlebars';
import fs from 'fs/promises';
import path from 'path';

class AdvancedEmailService {
  private transporter: nodemailer.Transporter;
  private templatesPath: string;

  constructor(config: EmailConfig, templatesPath: string) {
    this.transporter = nodemailer.createTransporter(config);
    this.templatesPath = templatesPath;
  }

  // 📄 Load and compile template
  private async loadTemplate(templateName: string): Promise<HandlebarsTemplateDelegate> {
    const templatePath = path.join(this.templatesPath, `${templateName}.hbs`);
    const templateContent = await fs.readFile(templatePath, 'utf-8');
    return handlebars.compile(templateContent);
  }

  // 📧 Send templated email
  async sendTemplatedEmail<T = any>(
    templateName: string,
    to: string,
    subject: string,
    data: T
  ): Promise<void> {
    try {
      const template = await this.loadTemplate(templateName);
      const html = template(data);

      await this.transporter.sendMail({
        from: '"TemplateApp 🎨" <[email protected]>',
        to,
        subject,
        html
      });

      console.log(`✨ Templated email sent: ${templateName} to ${to}`);
    } catch (error) {
      console.error('❌ Template email failed:', error);
      throw error;
    }
  }
}

// 🎯 Usage with type safety
interface WelcomeEmailData {
  userName: string;
  appName: string;
  features: string[];
  ctaUrl: string;
}

const emailService = new AdvancedEmailService(emailConfig, './templates');

// 📧 Send welcome email with template
await emailService.sendTemplatedEmail<WelcomeEmailData>(
  'welcome', 
  '[email protected]',
  'Welcome to our amazing app! 🎉',
  {
    userName: 'Sarah',
    appName: 'CodeMaster',
    features: ['💻 Code Editor', '🔍 Live Preview', '🤝 Collaboration'],
    ctaUrl: 'https://codemaster.com/dashboard'
  }
);

🏗️ Advanced Topic 2: Email Queue System

For the brave developers, here’s a scalable email queue:

// 📬 Email queue with Bull (Redis-based)
import Queue from 'bull';

interface EmailJob {
  type: 'welcome' | 'verification' | 'reset-password' | 'order-confirmation';
  to: string;
  data: any;
}

class EmailQueueService {
  private emailQueue: Queue.Queue<EmailJob>;
  private emailService: AdvancedEmailService;

  constructor(redisConfig: any, emailService: AdvancedEmailService) {
    this.emailQueue = new Queue('email processing', redisConfig);
    this.emailService = emailService;
    this.setupWorkers();
  }

  // 🔄 Setup queue workers
  private setupWorkers(): void {
    this.emailQueue.process('send-email', 5, async (job) => {
      const { type, to, data } = job.data;
      
      console.log(`📧 Processing ${type} email for ${to}`);
      
      switch (type) {
        case 'welcome':
          await this.emailService.sendTemplatedEmail('welcome', to, 'Welcome! 🎉', data);
          break;
        case 'verification':
          await this.emailService.sendTemplatedEmail('verification', to, 'Verify Email 🔐', data);
          break;
        // ... more cases
      }
      
      console.log(`✅ Email sent: ${type} to ${to}`);
    });

    // 📊 Queue event listeners
    this.emailQueue.on('completed', (job, result) => {
      console.log(`🎉 Job ${job.id} completed`);
    });

    this.emailQueue.on('failed', (job, err) => {
      console.log(`❌ Job ${job.id} failed:`, err.message);
    });
  }

  // ➕ Add email to queue
  async queueEmail(emailJob: EmailJob): Promise<void> {
    await this.emailQueue.add('send-email', emailJob, {
      attempts: 3,
      backoff: 'exponential',
      delay: 5000
    });
    
    console.log(`📬 Email queued: ${emailJob.type} for ${emailJob.to}`);
  }
}

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Hardcoded Credentials

// ❌ Wrong way - security nightmare!
const transporter = nodemailer.createTransporter({
  service: 'gmail',
  auth: {
    user: '[email protected]',     // 😰 Exposed!
    pass: 'mypassword123'          // 💥 Very dangerous!
  }
});

// ✅ Correct way - use environment variables!
const transporter = nodemailer.createTransporter({
  service: 'gmail',
  auth: {
    user: process.env.EMAIL_USER,    // 🛡️ Secure!
    pass: process.env.EMAIL_PASS     // 🔒 App-specific password
  }
});

// 💡 Add to your .env file:
// [email protected]
// EMAIL_PASS=your-app-specific-password

🤯 Pitfall 2: Not Handling Async Errors

// ❌ Dangerous - unhandled promise rejection!
function sendEmail() {
  transporter.sendMail(message); // 💥 No error handling!
}

// ✅ Safe - proper error handling!
async function sendEmail(): Promise<void> {
  try {
    const info = await transporter.sendMail(message);
    console.log('✅ Email sent:', info.messageId);
  } catch (error) {
    console.error('❌ Email failed:', error);
    // 🚨 Maybe add to retry queue or alert admins
    throw error;
  }
}

🚫 Pitfall 3: HTML Injection Vulnerability

// ❌ Vulnerable to XSS attacks!
function sendWelcomeEmail(userName: string): void {
  const html = `<h1>Welcome ${userName}!</h1>`; // 💥 No sanitization!
}

// ✅ Safe - sanitize user input!
import DOMPurify from 'isomorphic-dompurify';

function sendWelcomeEmail(userName: string): void {
  const sanitizedName = DOMPurify.sanitize(userName);
  const html = `<h1>Welcome ${sanitizedName}!</h1>`; // 🛡️ Safe now!
}

🛠️ Best Practices

🔐 Security First: Always use environment variables for credentials
📝 Template System: Use templates for complex emails
🚀 Queue System: Use queues for high-volume email sending
🛡️ Input Sanitization: Never trust user input in email content
📊 Error Handling: Always handle email failures gracefully
⚡ Rate Limiting: Respect email provider rate limits
📱 Mobile-Friendly: Design responsive email templates
🧪 Testing: Test emails with different providers

🧪 Hands-On Exercise

Create a complete newsletter system with subscription management:

📋 Requirements:

✅ Subscribe/unsubscribe functionality
📧 Welcome email for new subscribers
📰 Send newsletter to all subscribers
📊 Track email delivery status
🎨 Use HTML templates
🔄 Queue system for bulk emails

🚀 Bonus Points:

Add email preferences (daily/weekly)
Implement A/B testing for subject lines
Add click tracking
Create an admin dashboard

💡 Solution

🔍 Click to see solution

// 📰 Complete newsletter system
interface Subscriber {
  id: string;
  email: string;
  name: string;
  subscribedAt: Date;
  preferences: {
    frequency: 'daily' | 'weekly' | 'monthly';
    topics: string[];
  };
  isActive: boolean;
}

interface Newsletter {
  id: string;
  subject: string;
  content: string;
  scheduledFor: Date;
  status: 'draft' | 'scheduled' | 'sent';
}

class NewsletterService {
  private transporter: nodemailer.Transporter;
  private subscribers: Map<string, Subscriber> = new Map();
  private newsletters: Newsletter[] = [];

  constructor(config: EmailConfig) {
    this.transporter = nodemailer.createTransporter(config);
  }

  // ➕ Subscribe user
  async subscribe(email: string, name: string): Promise<void> {
    const subscriber: Subscriber = {
      id: Date.now().toString(),
      email,
      name,
      subscribedAt: new Date(),
      preferences: {
        frequency: 'weekly',
        topics: ['tech', 'tutorials']
      },
      isActive: true
    };

    this.subscribers.set(subscriber.id, subscriber);
    
    // 🎉 Send welcome email
    await this.sendWelcomeEmail(subscriber);
    console.log(`✅ New subscriber: ${email}`);
  }

  // ✉️ Send welcome email
  private async sendWelcomeEmail(subscriber: Subscriber): Promise<void> {
    const welcomeHtml = `
      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
        <h2>🎉 Welcome to Our Newsletter, ${subscriber.name}!</h2>
        <p>Thanks for subscribing! You'll receive our ${subscriber.preferences.frequency} updates.</p>
        
        <div style="background-color: #f0f8ff; padding: 20px; margin: 20px 0; border-radius: 8px;">
          <h3>📚 What to Expect:</h3>
          <ul>
            <li>🔥 Latest tech trends and tutorials</li>
            <li>💡 Programming tips and tricks</li>
            <li>🚀 Project inspiration and ideas</li>
            <li>📈 Industry insights and analysis</li>
          </ul>
        </div>
        
        <p>You can update your preferences or unsubscribe anytime. 🛠️</p>
        <p>Happy learning! 📖✨</p>
      </div>
    `;

    await this.transporter.sendMail({
      from: '"Newsletter Team 📰" <[email protected]>',
      to: subscriber.email,
      subject: `Welcome to our community, ${subscriber.name}! 🎉`,
      html: welcomeHtml
    });
  }

  // 📧 Send newsletter to all subscribers
  async sendNewsletter(newsletter: Newsletter): Promise<void> {
    const activeSubscribers = Array.from(this.subscribers.values())
      .filter(sub => sub.isActive);

    console.log(`📬 Sending newsletter to ${activeSubscribers.length} subscribers`);

    // 🔄 Send in batches to avoid rate limits
    const batchSize = 10;
    for (let i = 0; i < activeSubscribers.length; i += batchSize) {
      const batch = activeSubscribers.slice(i, i + batchSize);
      
      await Promise.all(batch.map(subscriber => 
        this.sendNewsletterToSubscriber(newsletter, subscriber)
      ));
      
      // ⏱️ Brief pause between batches
      await new Promise(resolve => setTimeout(resolve, 1000));
    }

    newsletter.status = 'sent';
    console.log(`✅ Newsletter sent to all ${activeSubscribers.length} subscribers`);
  }

  // 📬 Send newsletter to individual subscriber
  private async sendNewsletterToSubscriber(
    newsletter: Newsletter, 
    subscriber: Subscriber
  ): Promise<void> {
    const unsubscribeUrl = `https://yourapp.com/unsubscribe?id=${subscriber.id}`;
    
    const emailHtml = `
      <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
        <div style="text-align: center; padding: 20px; background-color: #f8f9fa;">
          <h1>📰 Weekly Newsletter</h1>
        </div>
        
        <div style="padding: 20px;">
          <p>Hi ${subscriber.name}! 👋</p>
          ${newsletter.content}
        </div>
        
        <div style="padding: 20px; background-color: #f8f9fa; text-align: center; margin-top: 30px;">
          <p style="color: #666; font-size: 12px;">
            📬 You're receiving this because you subscribed to our newsletter.<br>
            <a href="${unsubscribeUrl}" style="color: #007bff;">Unsubscribe</a> | 
            <a href="https://yourapp.com/preferences?id=${subscriber.id}" style="color: #007bff;">Update Preferences</a>
          </p>
        </div>
      </div>
    `;

    try {
      await this.transporter.sendMail({
        from: '"Weekly Newsletter 📰" <[email protected]>',
        to: subscriber.email,
        subject: newsletter.subject,
        html: emailHtml
      });
      
      console.log(`📧 Newsletter sent to ${subscriber.email}`);
    } catch (error) {
      console.error(`❌ Failed to send newsletter to ${subscriber.email}:`, error);
    }
  }

  // 📊 Get subscriber statistics
  getStats(): void {
    const total = this.subscribers.size;
    const active = Array.from(this.subscribers.values()).filter(s => s.isActive).length;
    
    console.log('📊 Newsletter Stats:');
    console.log(`  📝 Total Subscribers: ${total}`);
    console.log(`  ✅ Active Subscribers: ${active}`);
    console.log(`  📰 Newsletters Sent: ${this.newsletters.filter(n => n.status === 'sent').length}`);
  }
}

// 🎮 Test the newsletter system!
const newsletterService = new NewsletterService(emailConfig);

// Add some subscribers
await newsletterService.subscribe('[email protected]', 'Alice');
await newsletterService.subscribe('[email protected]', 'Bob');

// Create and send newsletter
const newsletter: Newsletter = {
  id: '1',
  subject: '🚀 This Week in Tech: AI Breakthroughs & More!',
  content: `
    <h2>🔥 Hot Topics This Week</h2>
    <ul>
      <li>🤖 AI advances in code generation</li>
      <li>📱 New mobile development frameworks</li>
      <li>🔒 Latest in cybersecurity</li>
    </ul>
    <p>Keep coding and stay awesome! 💪</p>
  `,
  scheduledFor: new Date(),
  status: 'draft'
};

await newsletterService.sendNewsletter(newsletter);

🎓 Key Takeaways

You’ve learned so much! Here’s what you can now do:

✅ Set up Nodemailer with TypeScript and proper configuration 💪
✅ Create email templates that look professional and engaging 🛡️
✅ Handle authentication and security best practices 🎯
✅ Build scalable systems with queues and error handling 🐛
✅ Avoid common pitfalls that cause security vulnerabilities 🚀

Remember: Email services are powerful tools that can significantly enhance user engagement. Use them wisely and always prioritize user privacy and security! 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered email services with Nodemailer!

Here’s what to do next:

💻 Practice with the newsletter system exercise
🏗️ Build a real project with email notifications
📚 Explore advanced topics like email analytics and A/B testing
🌟 Learn about email marketing best practices and deliverability

Your next tutorial: Message Queues: RabbitMQ and Kafka - Learn how to build scalable message-driven architectures! 🚀

Remember: Every email expert was once a beginner. Keep coding, keep learning, and most importantly, have fun building amazing email experiences! 🚀

Happy coding! 🎉🚀✨

Prerequisites

What you'll learn

🎯 Introduction

📚 Understanding Email Services

🤔 What is Nodemailer?

💡 Why Use Nodemailer?

🔧 Basic Syntax and Usage

📝 Installation and Setup

🎯 Basic Configuration

🎮 Simple Email Example

💡 Practical Examples

🛒 Example 1: E-commerce Order Confirmation

🎮 Example 2: User Authentication System

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Email Templates with Handlebars

🏗️ Advanced Topic 2: Email Queue System

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Hardcoded Credentials

🤯 Pitfall 2: Not Handling Async Errors

🚫 Pitfall 3: HTML Injection Vulnerability

🛠️ Best Practices

🧪 Hands-On Exercise

💡 Solution

🎓 Key Takeaways

🤝 Next Steps

More typescript Tutorials

📘 File Uploads: Multer Integration

📧 Email Services: Nodemailer Setup

📘 Cron Jobs: Task Scheduling

Tutorial Info

📧 Email Services: Nodemailer Setup

Prerequisites

What you'll learn

🎯 Introduction

📚 Understanding Email Services

🤔 What is Nodemailer?

💡 Why Use Nodemailer?

🔧 Basic Syntax and Usage

📝 Installation and Setup

🎯 Basic Configuration

🎮 Simple Email Example

💡 Practical Examples

🛒 Example 1: E-commerce Order Confirmation

🎮 Example 2: User Authentication System

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Email Templates with Handlebars

🏗️ Advanced Topic 2: Email Queue System

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Hardcoded Credentials

🤯 Pitfall 2: Not Handling Async Errors

🚫 Pitfall 3: HTML Injection Vulnerability

🛠️ Best Practices

🧪 Hands-On Exercise

🎯 Challenge: Build a Newsletter System

💡 Solution

🎓 Key Takeaways

🤝 Next Steps

More typescript Tutorials

📘 File Uploads: Multer Integration

📧 Email Services: Nodemailer Setup

📘 Cron Jobs: Task Scheduling

Tutorial Info