Back to blog
InspectionJanuary 1, 2024· 13 min read

DNS Propagation: How to Monitor and Speed Up DNS Changes Worldwide

A practical Fusebox guide to dns propagation.

DNS Propagation: How to Monitor and Speed Up DNS Changes Worldwide

Published: January 2024
Reading time: 8 minutes

DNS changes don't happen instantly. When you update DNS records, it can take minutes to 48 hours for the changes to spread worldwide. Here's how DNS propagation works, why it matters, and how to monitor it effectively.

What Is DNS Propagation?

DNS propagation is the time it takes for DNS changes to update across all DNS servers worldwide. When you change a DNS record:

  1. You update → Your DNS provider
  2. Provider updates → Root servers
  3. Root servers notify → ISP servers
  4. ISPs cache → Local resolvers
  5. Users see → New DNS results

This process isn't instant because of caching at every level.

Why DNS Propagation Matters

Business Impact

  • Website migrations - Old server gets traffic during propagation
  • Email delivery - MX changes affect mail routing
  • Security updates - SPF/DKIM changes need quick propagation
  • Load balancing - Traffic distribution depends on DNS
  • Downtime windows - Planning around propagation time

Real-World Scenarios

Scenario: Moving to new hosting
Risk: 24-48 hours of split traffic
Impact: Some users see old site, others see new

Scenario: Emergency DNS fix
Risk: Security vulnerability remains exposed
Impact: Attackers exploit during propagation

Scenario: Email provider change
Risk: Lost emails during transition
Impact: Business communication disrupted

Understanding TTL (Time To Live)

How TTL Controls Propagation

// TTL determines how long DNS records are cached
function explainTTL() {
  console.log('⏱️ Understanding TTL (Time To Live)\n');
  
  const ttlExamples = {
    '300 (5 minutes)': {
      use: 'Frequent changes, migrations',
      propagation: '5-15 minutes typical',
      pros: 'Fast updates',
      cons: 'More DNS queries'
    },
    '3600 (1 hour)': {
      use: 'Standard for most records',
      propagation: '1-4 hours typical',
      pros: 'Balanced performance',
      cons: 'Moderate update time'
    },
    '86400 (24 hours)': {
      use: 'Stable records, static IPs',
      propagation: '24-48 hours typical',
      pros: 'Best performance',
      cons: 'Slow updates'
    },
    '604800 (7 days)': {
      use: 'Very stable infrastructure',
      propagation: 'Up to 7 days',
      pros: 'Minimal DNS load',
      cons: 'Very slow changes'
    }
  };
  
  console.log('TTL Settings and Impact:\n');
  Object.entries(ttlExamples).forEach(([ttl, info]) => {
    console.log(`📊 TTL: ${ttl}`);
    console.log(`  Use case: ${info.use}`);
    console.log(`  Propagation: ${info.propagation}`);
    console.log(`  ✅ ${info.pros}`);
    console.log(`  ⚠️ ${info.cons}\n`);
  });
}

explainTTL();

Pre-Migration TTL Strategy

// Optimal TTL strategy for DNS changes
function planDNSMigration(currentTTL, migrationDate) {
  console.log('📋 DNS Migration Planning\n');
  
  const plan = [];
  const secondsInDay = 86400;
  const currentTTLSeconds = currentTTL;
  
  // Calculate preparation timeline
  if (currentTTLSeconds > 3600) {
    // Need to lower TTL in advance
    const daysNeeded = Math.ceil(currentTTLSeconds / secondsInDay) + 1;
    
    plan.push({
      when: `${daysNeeded} days before`,
      action: 'Lower TTL to 300 seconds (5 minutes)',
      reason: 'Prepare for fast propagation'
    });
    
    plan.push({
      when: '24 hours before',
      action: 'Verify TTL has propagated',
      reason: 'Ensure all servers have low TTL'
    });
  }
  
  plan.push({
    when: 'Migration time',
    action: 'Update DNS records',
    reason: 'Point to new server/service'
  });
  
  plan.push({
    when: '1 hour after',
    action: 'Check propagation status',
    reason: 'Monitor global DNS spread'
  });
  
  plan.push({
    when: '24 hours after',
    action: 'Raise TTL back to normal',
    reason: 'Optimize performance'
  });
  
  console.log('Migration Timeline:');
  plan.forEach((step, index) => {
    console.log(`\n${index + 1}. ${step.when}`);
    console.log(`   Action: ${step.action}`);
    console.log(`   Why: ${step.reason}`);
  });
  
  return plan;
}

// Example: Current TTL is 24 hours
planDNSMigration(86400, '2024-02-01');

Monitoring DNS Propagation

1. Global DNS Checker

// Check DNS propagation across multiple locations
async function checkGlobalDNSPropagation(domain, recordType = 'A') {
  console.log(`\n🌍 Global DNS Propagation Check for ${domain}\n`);
  
  // Simulated DNS servers worldwide
  const dnsServers = [
    { location: 'US East (Virginia)', ip: '8.8.8.8', provider: 'Google' },
    { location: 'US West (California)', ip: '1.1.1.1', provider: 'Cloudflare' },
    { location: 'Europe (London)', ip: '9.9.9.9', provider: 'Quad9' },
    { location: 'Asia (Singapore)', ip: '208.67.222.222', provider: 'OpenDNS' },
    { location: 'Australia (Sydney)', ip: '8.8.4.4', provider: 'Google' },
    { location: 'South America (Brazil)', ip: '156.154.70.1', provider: 'UltraDNS' },
    { location: 'Africa (South Africa)', ip: '169.239.202.202', provider: 'SEACOM' },
    { location: 'Middle East (UAE)', ip: '94.140.14.14', provider: 'AdGuard' }
  ];
  
  // Expected new value
  const expectedValue = '192.168.1.100';
  let propagatedCount = 0;
  
  console.log(`Checking ${recordType} record across ${dnsServers.length} global DNS servers:`);
  console.log(`Expected value: ${expectedValue}\n`);
  
  // Check each DNS server
  for (const server of dnsServers) {
    // In reality, you'd query each DNS server
    // This simulates the results
    const randomDelay = Math.random() * 2000;
    const isPropagated = Math.random() > 0.3; // 70% propagated
    const currentValue = isPropagated ? expectedValue : '192.168.1.50';
    
    await new Promise(resolve => setTimeout(resolve, randomDelay));
    
    const status = isPropagated ? '✅' : '❌';
    console.log(`${status} ${server.location.padEnd(25)} ${currentValue.padEnd(15)} (${server.provider})`);
    
    if (isPropagated) propagatedCount++;
  }
  
  // Summary
  const propagationPercentage = (propagatedCount / dnsServers.length * 100).toFixed(1);
  console.log(`\n📊 Propagation Status: ${propagationPercentage}% complete`);
  console.log(`   ${propagatedCount}/${dnsServers.length} servers updated`);
  
  if (propagationPercentage < 50) {
    console.log(`\n⚠️ Low propagation - DNS changes still spreading`);
    console.log(`   Estimated completion: 2-4 hours`);
  } else if (propagationPercentage < 90) {
    console.log(`\n🟡 Partial propagation - Most servers updating`);
    console.log(`   Estimated completion: 30-60 minutes`);
  } else if (propagationPercentage < 100) {
    console.log(`\n🟢 Nearly complete - Final servers updating`);
    console.log(`   Estimated completion: 10-30 minutes`);
  } else {
    console.log(`\n✅ Propagation complete - All servers updated!`);
  }
  
  return { propagatedCount, total: dnsServers.length, percentage: propagationPercentage };
}

// Run propagation check
checkGlobalDNSPropagation('example.com', 'A');

2. DNS Cache Analysis

// Analyze DNS cache at different levels
function analyzeDNSCacheLevels(domain) {
  console.log(`\n🔍 DNS Cache Level Analysis for ${domain}\n`);
  
  const cacheLevels = [
    {
      level: 'Browser Cache',
      location: 'Your computer',
      ttl: 'Varies (usually 60-300 seconds)',
      clearMethod: 'Close browser or clear cache',
      command: 'chrome://net-internals/#dns'
    },
    {
      level: 'OS Cache',
      location: 'Operating system',
      ttl: 'Follows DNS TTL',
      clearMethod: 'Flush DNS cache',
      command: {
        windows: 'ipconfig /flushdns',
        mac: 'sudo dscacheutil -flushcache',
        linux: 'sudo systemctl restart systemd-resolved'
      }
    },
    {
      level: 'Router Cache',
      location: 'Local network router',
      ttl: 'Usually 300-3600 seconds',
      clearMethod: 'Restart router',
      command: 'Access router admin panel'
    },
    {
      level: 'ISP Cache',
      location: 'Internet service provider',
      ttl: 'Follows DNS TTL',
      clearMethod: 'Wait for TTL expiry',
      command: 'Cannot manually clear'
    },
    {
      level: 'Public DNS Cache',
      location: 'Google, Cloudflare, etc.',
      ttl: 'Respects TTL (min 30s)',
      clearMethod: 'Use purge tools if available',
      command: 'Some providers offer cache purge'
    }
  ];
  
  console.log('DNS Cache Hierarchy:\n');
  cacheLevels.forEach((cache, index) => {
    console.log(`${index + 1}. ${cache.level}`);
    console.log(`   📍 Location: ${cache.location}`);
    console.log(`   ⏱️ TTL: ${cache.ttl}`);
    console.log(`   🔧 Clear method: ${cache.clearMethod}`);
    
    if (typeof cache.command === 'object') {
      Object.entries(cache.command).forEach(([os, cmd]) => {
        console.log(`   💻 ${os}: ${cmd}`);
      });
    } else {
      console.log(`   💻 Command: ${cache.command}`);
    }
    console.log('');
  });
  
  // Impact analysis
  console.log('⚡ Propagation Impact:');
  console.log('• Each level adds delay to DNS updates');
  console.log('• Lower TTL = Faster propagation but more DNS queries');
  console.log('• ISP caches often ignore very low TTLs (<300s)');
  console.log('• Full propagation = All cache levels expired');
}

analyzeDNSCacheLevels('example.com');

3. Real-Time Propagation Monitor

// Monitor DNS propagation in real-time
class DNSPropagationMonitor {
  constructor(domain, expectedValue, recordType = 'A') {
    this.domain = domain;
    this.expectedValue = expectedValue;
    this.recordType = recordType;
    this.checkpoints = [];
    this.startTime = Date.now();
  }
  
  async startMonitoring(intervalMinutes = 5) {
    console.log(`\n⏱️ Starting DNS Propagation Monitor`);
    console.log(`Domain: ${this.domain}`);
    console.log(`Record Type: ${this.recordType}`);
    console.log(`Expected Value: ${this.expectedValue}`);
    console.log(`Check Interval: ${intervalMinutes} minutes\n`);
    
    // Initial check
    await this.checkPropagation();
    
    // Set up interval
    this.interval = setInterval(async () => {
      await this.checkPropagation();
      
      // Stop if fully propagated
      if (this.getLatestPropagation() === 100) {
        this.stopMonitoring();
        console.log('\n✅ Propagation complete! Monitoring stopped.');
      }
    }, intervalMinutes * 60 * 1000);
  }
  
  async checkPropagation() {
    const timestamp = new Date();
    const elapsed = Math.floor((Date.now() - this.startTime) / 1000 / 60);
    
    // Simulate propagation check
    const propagation = Math.min(100, elapsed * 10 + Math.random() * 20);
    
    this.checkpoints.push({
      timestamp,
      elapsed,
      propagation: propagation.toFixed(1)
    });
    
    console.log(`[${timestamp.toLocaleTimeString()}] Check #${this.checkpoints.length}`);
    console.log(`  Elapsed: ${elapsed} minutes`);
    console.log(`  Propagation: ${propagation.toFixed(1)}%`);
    console.log(`  Status: ${this.getPropagationStatus(propagation)}`);
    console.log('');
  }
  
  getPropagationStatus(percentage) {
    if (percentage < 25) return '🔴 Just started';
    if (percentage < 50) return '🟡 Spreading slowly';
    if (percentage < 75) return '🟢 Good progress';
    if (percentage < 100) return '🔵 Nearly complete';
    return '✅ Fully propagated';
  }
  
  getLatestPropagation() {
    if (this.checkpoints.length === 0) return 0;
    return parseFloat(this.checkpoints[this.checkpoints.length - 1].propagation);
  }
  
  stopMonitoring() {
    if (this.interval) {
      clearInterval(this.interval);
    }
    this.generateReport();
  }
  
  generateReport() {
    console.log('\n📊 Propagation Report');
    console.log('═'.repeat(40));
    console.log(`Total Time: ${this.checkpoints[this.checkpoints.length - 1].elapsed} minutes`);
    console.log(`Total Checks: ${this.checkpoints.length}`);
    console.log('\nPropagation Timeline:');
    
    this.checkpoints.forEach(checkpoint => {
      const bar = '█'.repeat(Math.floor(checkpoint.propagation / 5));
      console.log(`  ${checkpoint.elapsed.toString().padStart(3)}m: ${bar} ${checkpoint.propagation}%`);
    });
  }
}

// Example usage
const monitor = new DNSPropagationMonitor('example.com', '192.168.1.100');
// In practice: monitor.startMonitoring(5);

Speeding Up DNS Propagation

1. Pre-Change Optimization

// Strategies to speed up DNS propagation
function optimizeDNSPropagation() {
  console.log('\n🚀 DNS Propagation Optimization Strategies\n');
  
  const strategies = [
    {
      name: 'Lower TTL in Advance',
      timing: '24-48 hours before change',
      howTo: 'Set TTL to 300 seconds',
      impact: 'Reduces propagation from 24h to 1h',
      example: 'example.com IN A 300 192.168.1.1'
    },
    {
      name: 'Use Multiple DNS Providers',
      timing: 'Always',
      howTo: 'Configure secondary DNS provider',
      impact: 'Redundancy and faster global reach',
      example: 'NS1: ns1.provider1.com, NS2: ns1.provider2.com'
    },
    {
      name: 'Purge Major DNS Caches',
      timing: 'After DNS change',
      howTo: 'Use provider tools to purge cache',
      impact: 'Immediate update at major resolvers',
      example: 'Cloudflare: Purge Cache button'
    },
    {
      name: 'Geographic DNS Distribution',
      timing: 'Always',
      howTo: 'Use Anycast DNS network',
      impact: 'Faster propagation worldwide',
      example: 'Single IP routes to nearest server'
    },
    {
      name: 'Notify Secondary Servers',
      timing: 'After change',
      howTo: 'DNS NOTIFY mechanism',
      impact: 'Immediate secondary updates',
      example: 'Automatic with most providers'
    }
  ];
  
  strategies.forEach((strategy, index) => {
    console.log(`${index + 1}. ${strategy.name}`);
    console.log(`   ⏰ When: ${strategy.timing}`);
    console.log(`   🔧 How: ${strategy.howTo}`);
    console.log(`   ⚡ Impact: ${strategy.impact}`);
    console.log(`   📝 Example: ${strategy.example}\n`);
  });
}

optimizeDNSPropagation();

2. Emergency DNS Changes

// Handle emergency DNS updates
function emergencyDNSChange(issue, currentTTL) {
  console.log('\n🚨 Emergency DNS Change Protocol\n');
  console.log(`Issue: ${issue}`);
  console.log(`Current TTL: ${currentTTL} seconds\n`);
  
  const steps = [];
  
  if (issue.includes('security') || issue.includes('attack')) {
    steps.push({
      priority: 'IMMEDIATE',
      action: 'Update DNS records now',
      note: "Don't wait for TTL reduction"
    });
    
    steps.push({
      priority: 'HIGH',
      action: 'Contact major DNS providers',
      note: 'Request emergency cache flush'
    });
    
    steps.push({
      priority: 'HIGH',
      action: 'Update WAF/Security rules',
      note: 'Block attacks during propagation'
    });
  }
  
  steps.push({
    priority: 'MEDIUM',
    action: 'Monitor propagation closely',
    note: 'Check every 5 minutes'
  });
  
  steps.push({
    priority: 'MEDIUM',
    action: 'Prepare user communication',
    note: 'Explain potential issues'
  });
  
  console.log('Emergency Response Steps:');
  steps.forEach((step, index) => {
    const icon = step.priority === 'IMMEDIATE' ? '🔴' : 
                 step.priority === 'HIGH' ? '🟡' : '🟢';
    console.log(`\n${index + 1}. ${icon} ${step.action}`);
    console.log(`   Priority: ${step.priority}`);
    console.log(`   Note: ${step.note}`);
  });
  
  // Time estimates
  console.log('\n⏱️ Propagation Timeline:');
  console.log(`• 0-15 min: Major DNS providers update`);
  console.log(`• 15-60 min: Most ISPs update`);
  console.log(`• 1-4 hours: 90%+ propagation`);
  console.log(`• 4-24 hours: Full propagation`);
  
  if (currentTTL > 3600) {
    console.log(`\n⚠️ Warning: High TTL (${currentTTL}s) will slow propagation`);
    console.log(`   Consider provider-level cache purge`);
  }
}

emergencyDNSChange('Security breach - need to change server immediately', 86400);

DNS Propagation Testing Tools

1. Command Line DNS Testing

// DNS testing commands for different platforms
function dnsPropagationCommands() {
  console.log('\n💻 DNS Propagation Testing Commands\n');
  
  const commands = {
    'Check current DNS (Universal)': {
      command: 'nslookup example.com',
      output: 'Shows current DNS resolution',
      platforms: 'All'
    },
    'Check specific DNS server': {
      command: 'nslookup example.com 8.8.8.8',
      output: 'Query Google DNS specifically',
      platforms: 'All'
    },
    'Detailed DNS query (Linux/Mac)': {
      command: 'dig example.com @8.8.8.8',
      output: 'Detailed DNS information',
      platforms: 'Linux, macOS'
    },
    'Trace DNS path': {
      command: 'dig +trace example.com',
      output: 'Shows full DNS resolution path',
      platforms: 'Linux, macOS'
    },
    'Check all record types': {
      command: 'dig example.com ANY',
      output: 'Shows A, AAAA, MX, TXT, etc.',
      platforms: 'Linux, macOS'
    },
    'Windows DNS cache': {
      command: 'ipconfig /displaydns | findstr example.com',
      output: 'Shows cached DNS entries',
      platforms: 'Windows'
    },
    'Force fresh lookup': {
      command: 'dig example.com @8.8.8.8 +nocache',
      output: 'Bypasses cache',
      platforms: 'Linux, macOS'
    }
  };
  
  Object.entries(commands).forEach(([description, details]) => {
    console.log(`📝 ${description}`);
    console.log(`   Command: ${details.command}`);
    console.log(`   Output: ${details.output}`);
    console.log(`   Platforms: ${details.platforms}\n`);
  });
  
  // PowerShell for advanced Windows users
  console.log('🔧 Advanced Windows (PowerShell):');
  console.log('   Resolve-DnsName example.com -Type A -Server 8.8.8.8');
  console.log('   Clear-DnsClientCache');
}

dnsPropagationCommands();

2. Automated Propagation Checker

// Build automated DNS propagation checker
class AutomatedDNSChecker {
  constructor(domain, recordType, expectedValue) {
    this.domain = domain;
    this.recordType = recordType;
    this.expectedValue = expectedValue;
    this.servers = [
      { name: 'Google', ip: '8.8.8.8' },
      { name: 'Cloudflare', ip: '1.1.1.1' },
      { name: 'Quad9', ip: '9.9.9.9' },
      { name: 'OpenDNS', ip: '208.67.222.222' },
      { name: 'Level3', ip: '4.2.2.1' },
      { name: 'Verisign', ip: '64.6.64.6' },
      { name: 'Comodo', ip: '8.26.56.26' },
      { name: 'AdGuard', ip: '94.140.14.14' }
    ];
  }
  
  async checkAllServers() {
    console.log(`\n🔍 Checking DNS propagation for ${this.domain}`);
    console.log(`Record Type: ${this.recordType}`);
    console.log(`Expected: ${this.expectedValue}\n`);
    
    const results = [];
    
    for (const server of this.servers) {
      // In practice, you'd actually query the DNS server
      const result = await this.queryDNSServer(server);
      results.push(result);
      
      const status = result.value === this.expectedValue ? '✅' : '❌';
      const value = result.value || 'No response';
      
      console.log(`${status} ${server.name.padEnd(12)} (${server.ip}): ${value}`);
    }
    
    return this.generateSummary(results);
  }
  
  async queryDNSServer(server) {
    // Simulated DNS query
    await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
    
    // Simulate varying propagation
    const propagated = Math.random() > 0.2;
    
    return {
      server: server.name,
      ip: server.ip,
      value: propagated ? this.expectedValue : '192.168.1.50',
      responseTime: Math.floor(Math.random() * 100) + 10,
      timestamp: new Date()
    };
  }
  
  generateSummary(results) {
    const propagated = results.filter(r => r.value === this.expectedValue).length;
    const percentage = (propagated / results.length * 100).toFixed(1);
    
    console.log(`\n📊 Summary:`);
    console.log(`   Propagated: ${propagated}/${results.length} servers (${percentage}%)`);
    
    const avgResponseTime = results.reduce((sum, r) => sum + r.responseTime, 0) / results.length;
    console.log(`   Avg Response Time: ${avgResponseTime.toFixed(0)}ms`);
    
    if (percentage < 100) {
      const estimatedTime = this.estimateCompletionTime(percentage);
      console.log(`   Estimated Completion: ${estimatedTime}`);
    }
    
    return { propagated, total: results.length, percentage };
  }
  
  estimateCompletionTime(currentPercentage) {
    if (currentPercentage < 25) return '2-4 hours';
    if (currentPercentage < 50) return '1-2 hours';
    if (currentPercentage < 75) return '30-60 minutes';
    if (currentPercentage < 90) return '15-30 minutes';
    return '5-15 minutes';
  }
}

// Example usage
const checker = new AutomatedDNSChecker('example.com', 'A', '192.168.1.100');
checker.checkAllServers();

Common Propagation Issues

1. Troubleshooting Slow Propagation

// Diagnose why DNS propagation is slow
function troubleshootSlowPropagation(domain, hoursElapsed) {
  console.log(`\n🔧 Troubleshooting Slow DNS Propagation\n`);
  console.log(`Domain: ${domain}`);
  console.log(`Time elapsed: ${hoursElapsed} hours\n`);
  
  const issues = [];
  
  // Check common problems
  if (hoursElapsed > 24) {
    issues.push({
      problem: 'Very slow propagation (>24 hours)',
      causes: [
        'High TTL value (check current TTL)',
        'DNS provider issues',
        'Negative caching from previous errors'
      ],
      solutions: [
        'Contact DNS provider support',
        'Check for DNS configuration errors',
        'Consider provider cache flush'
      ]
    });
  }
  
  if (hoursElapsed > 4) {
    issues.push({
      problem: 'Slower than expected',
      causes: [
        'ISPs ignoring low TTL',
        'Geographic distance from DNS servers',
        'Heavy DNS caching layers'
      ],
      solutions: [
        'Wait for original TTL to expire',
        'Use global DNS monitoring',
        'Check specific problem regions'
      ]
    });
  }
  
  issues.push({
    problem: 'Inconsistent propagation',
    causes: [
      'Multiple DNS providers out of sync',
      'DNSSEC validation failures',
      'Conflicting DNS records'
    ],
    solutions: [
      'Verify all nameservers have same records',
      'Check DNSSEC configuration',
      'Remove duplicate or conflicting records'
    ]
  });
  
  console.log('Potential Issues Found:\n');
  issues.forEach((issue, index) => {
    console.log(`${index + 1}. ${issue.problem}`);
    console.log('\n   Possible causes:');
    issue.causes.forEach(cause => console.log(`   • ${cause}`));
    console.log('\n   Solutions:');
    issue.solutions.forEach(solution => console.log(`   ✓ ${solution}`));
    console.log('');
  });
  
  // Quick checks
  console.log('🔍 Quick Diagnostic Commands:\n');
  console.log('1. Check TTL: dig +nocmd example.com +noall +answer');
  console.log('2. Check all nameservers: dig +nssearch example.com');
  console.log('3. Check DNSSEC: dig +dnssec example.com');
  console.log('4. Trace resolution: dig +trace example.com');
}

troubleshootSlowPropagation('example.com', 36);

Complete DNS Propagation Guide

// Comprehensive DNS propagation management
async function completeDNSPropagationGuide(action, domain) {
  console.log('📚 COMPLETE DNS PROPAGATION GUIDE');
  console.log('═'.repeat(50));
  console.log(`Action: ${action}`);
  console.log(`Domain: ${domain}`);
  console.log(`Date: ${new Date().toLocaleDateString()}\n`);
  
  switch(action) {
    case 'pre-migration':
      console.log('📋 PRE-MIGRATION CHECKLIST\n');
      console.log('7 days before:');
      console.log('  ☐ Document current DNS settings');
      console.log('  ☐ Test new server/service');
      console.log('  ☐ Plan rollback procedure\n');
      
      console.log('48 hours before:');
      console.log('  ☐ Lower TTL to 300 seconds');
      console.log('  ☐ Verify TTL change propagated');
      console.log('  ☐ Notify team of maintenance window\n');
      
      console.log('24 hours before:');
      console.log('  ☐ Final testing of new configuration');
      console.log('  ☐ Prepare monitoring tools');
      console.log('  ☐ Review emergency procedures');
      break;
      
    case 'migration':
      console.log('🚀 MIGRATION EXECUTION\n');
      console.log('Step 1: Update DNS records');
      console.log('Step 2: Document exact time of change');
      console.log('Step 3: Start propagation monitoring');
      console.log('Step 4: Test from multiple locations');
      console.log('Step 5: Monitor error logs');
      console.log('Step 6: Communicate status to team');
      break;
      
    case 'post-migration':
      console.log('✅ POST-MIGRATION TASKS\n');
      console.log('After 1 hour:');
      console.log('  ☐ Check 50%+ propagation');
      console.log('  ☐ Monitor both old and new servers');
      console.log('  ☐ Address any issues\n');
      
      console.log('After 24 hours:');
      console.log('  ☐ Verify 100% propagation');
      console.log('  ☐ Raise TTL back to normal');
      console.log('  ☐ Decommission old server');
      console.log('  ☐ Document lessons learned');
      break;
  }
  
  console.log('\n💡 Best Practices:');
  console.log('• Always lower TTL before changes');
  console.log('• Monitor propagation actively');
  console.log('• Have rollback plan ready');
  console.log('• Communicate with stakeholders');
  console.log('• Document everything');
}

// Example usage
completeDNSPropagationGuide('pre-migration', 'example.com');

The Bottom Line

DNS propagation is critical for:

  • Zero-downtime migrations - Plan around propagation time
  • Security updates - Fast propagation protects users
  • Email deliverability - MX changes affect business
  • Global performance - Users worldwide need updates
  • Business continuity - Minimize transition disruption

Master DNS propagation to execute flawless infrastructure changes.

Monitor DNS propagation instantly: Fusebox tracks DNS changes across global servers in real-time. See propagation status, TTL values, and get alerts. $29 one-time purchase.