instantly-migration-deep-dive

Execute Instantly major re-architecture and migration strategies with strangler fig pattern.Use when migrating to or from Instantly, performing major version upgrades,or re-platforming existing integrations to Instantly.Trigger with phrases like "migrate instantly", "instantly migration","switch to instantly", "instantly replatform", "instantly upgrade major".

⭐939stars🔀114forks📁View on GitHub🕐Updated Jan 11, 2026⬇️1downloads

When & Why to Use This Skill

The Instantly Migration Deep Dive skill is a comprehensive technical framework designed to facilitate seamless transitions to or from the Instantly platform. By leveraging the Strangler Fig pattern, it enables developers to execute major re-architectures, version upgrades, and re-platforming with minimal risk. It provides automated assessment scripts, adapter layer templates, and traffic-shifting strategies to ensure data integrity and system stability throughout the migration lifecycle.

Use Cases

  • Case 1: Migrating from a competitor outreach tool to Instantly using a phased, parallel-run approach to ensure zero downtime.
  • Case 2: Performing major version upgrades of the Instantly SDK within a production environment while maintaining a tested rollback strategy.
  • Case 3: Implementing a Strangler Fig pattern to gradually replace legacy integration code with a modern, scalable Instantly adapter layer.
  • Case 4: Automating the pre-migration assessment to identify integration points, data dependencies, and record counts across complex codebases.
nameinstantly-migration-deep-dive
description|
allowed-toolsRead, Write, Edit, Bash(npm:*), Bash(node:*), Bash(kubectl:*)
version1.0.0
licenseMIT
authorJeremy Longshore <jeremy@intentsolutions.io>

Instantly Migration Deep Dive

Overview

Comprehensive guide for migrating to or from Instantly, or major version upgrades.

Prerequisites

  • Current system documentation
  • Instantly SDK installed
  • Feature flag infrastructure
  • Rollback strategy tested

Migration Types

Type Complexity Duration Risk
Fresh install Low Days Low
From competitor Medium Weeks Medium
Major version Medium Weeks Medium
Full replatform High Months High

Pre-Migration Assessment

Step 1: Current State Analysis

# Document current implementation
find . -name "*.ts" -o -name "*.py" | xargs grep -l "instantly" > instantly-files.txt

# Count integration points
wc -l instantly-files.txt

# Identify dependencies
npm list | grep instantly
pip freeze | grep instantly

Step 2: Data Inventory

interface MigrationInventory {
  dataTypes: string[];
  recordCounts: Record<string, number>;
  dependencies: string[];
  integrationPoints: string[];
  customizations: string[];
}

async function assessInstantlyMigration(): Promise<MigrationInventory> {
  return {
    dataTypes: await getDataTypes(),
    recordCounts: await getRecordCounts(),
    dependencies: await analyzeDependencies(),
    integrationPoints: await findIntegrationPoints(),
    customizations: await documentCustomizations(),
  };
}

Migration Strategy: Strangler Fig Pattern

Phase 1: Parallel Run
┌─────────────┐     ┌─────────────┐
│   Old       │     │   New       │
│   System    │ ──▶ │  Instantly   │
│   (100%)    │     │   (0%)      │
└─────────────┘     └─────────────┘

Phase 2: Gradual Shift
┌─────────────┐     ┌─────────────┐
│   Old       │     │   New       │
│   (50%)     │ ──▶ │   (50%)     │
└─────────────┘     └─────────────┘

Phase 3: Complete
┌─────────────┐     ┌─────────────┐
│   Old       │     │   New       │
│   (0%)      │ ──▶ │   (100%)    │
└─────────────┘     └─────────────┘

Implementation Plan

Phase 1: Setup (Week 1-2)

# Install Instantly SDK
npm install @instantly/sdk

# Configure credentials
cp .env.example .env.instantly
# Edit with new credentials

# Verify connectivity
node -e "require('@instantly/sdk').ping()"

Phase 2: Adapter Layer (Week 3-4)

// src/adapters/instantly.ts
interface ServiceAdapter {
  create(data: CreateInput): Promise<Resource>;
  read(id: string): Promise<Resource>;
  update(id: string, data: UpdateInput): Promise<Resource>;
  delete(id: string): Promise<void>;
}

class InstantlyAdapter implements ServiceAdapter {
  async create(data: CreateInput): Promise<Resource> {
    const instantlyData = this.transform(data);
    return instantlyClient.create(instantlyData);
  }

  private transform(data: CreateInput): InstantlyInput {
    // Map from old format to Instantly format
  }
}

Phase 3: Data Migration (Week 5-6)

async function migrateInstantlyData(): Promise<MigrationResult> {
  const batchSize = 100;
  let processed = 0;
  let errors: MigrationError[] = [];

  for await (const batch of oldSystem.iterateBatches(batchSize)) {
    try {
      const transformed = batch.map(transform);
      await instantlyClient.batchCreate(transformed);
      processed += batch.length;
    } catch (error) {
      errors.push({ batch, error });
    }

    // Progress update
    console.log(`Migrated ${processed} records`);
  }

  return { processed, errors };
}

Phase 4: Traffic Shift (Week 7-8)

// Feature flag controlled traffic split
function getServiceAdapter(): ServiceAdapter {
  const instantlyPercentage = getFeatureFlag('instantly_migration_percentage');

  if (Math.random() * 100 < instantlyPercentage) {
    return new InstantlyAdapter();
  }

  return new LegacyAdapter();
}

Rollback Plan

# Immediate rollback
kubectl set env deployment/app INSTANTLY_ENABLED=false
kubectl rollout restart deployment/app

# Data rollback (if needed)
./scripts/restore-from-backup.sh --date YYYY-MM-DD

# Verify rollback
curl https://app.yourcompany.com/health | jq '.services.instantly'

Post-Migration Validation

async function validateInstantlyMigration(): Promise<ValidationReport> {
  const checks = [
    { name: 'Data count match', fn: checkDataCounts },
    { name: 'API functionality', fn: checkApiFunctionality },
    { name: 'Performance baseline', fn: checkPerformance },
    { name: 'Error rates', fn: checkErrorRates },
  ];

  const results = await Promise.all(
    checks.map(async c => ({ name: c.name, result: await c.fn() }))
  );

  return { checks: results, passed: results.every(r => r.result.success) };
}

Instructions

Step 1: Assess Current State

Document existing implementation and data inventory.

Step 2: Build Adapter Layer

Create abstraction layer for gradual migration.

Step 3: Migrate Data

Run batch data migration with error handling.

Step 4: Shift Traffic

Gradually route traffic to new Instantly integration.

Output

  • Migration assessment complete
  • Adapter layer implemented
  • Data migrated successfully
  • Traffic fully shifted to Instantly

Error Handling

Issue Cause Solution
Data mismatch Transform errors Validate transform logic
Performance drop No caching Add caching layer
Rollback triggered Errors spiked Reduce traffic percentage
Validation failed Missing data Check batch processing

Examples

Quick Migration Status

const status = await validateInstantlyMigration();
console.log(`Migration ${status.passed ? 'PASSED' : 'FAILED'}`);
status.checks.forEach(c => console.log(`  ${c.name}: ${c.result.success}`));

Resources

Flagship+ Skills

For advanced troubleshooting, see instantly-advanced-troubleshooting.