Enterprise Implementation Workflow | Bootspring Docs

The Enterprise Implementation workflow provides a structured approach to successfully onboarding enterprise customers, from kickoff through go-live and ongoing success management.

Overview#

Property	Value
Phases	5
Tier	Business
Typical Duration	4-12 weeks
Best For	Enterprise customer onboarding, professional services

Why Implementation Matters#

Enterprise implementations are complex and high-stakes:

Multiple stakeholders - IT, security, end users, executives
Data migration - Legacy systems with years of data
Integration requirements - Must fit into existing stack
Change management - User adoption is critical
High expectations - Enterprise customers expect white-glove service

A failed implementation can result in churn, negative references, and lost revenue.

Implementation Success Framework#

┌─────────────────────────────────────────────────────────────────────────┐
│                    ENTERPRISE IMPLEMENTATION PHASES                     │
├─────────────┬─────────────┬─────────────┬─────────────┬─────────────────┤
│   Kickoff   │   Setup     │  Migration  │  Training   │   Go-Live       │
│  (1 week)   │ (2-3 weeks) │ (2-4 weeks) │  (1 week)   │  (1-2 weeks)    │
├─────────────┼─────────────┼─────────────┼─────────────┼─────────────────┤
│ Stakeholder │ Environment │ Data        │ Admin       │ Staged          │
│ alignment   │ provisioning│ extraction  │ training    │ rollout         │
│             │             │             │             │                 │
│ Success     │ SSO config  │ Data        │ End user    │ Monitoring      │
│ criteria    │             │ transform   │ training    │                 │
│             │             │             │             │                 │
│ Project     │ Integration │ Data        │ Documentation│ Support         │
│ plan        │ setup       │ validation  │             │ handoff         │
│             │             │             │             │                 │
│ Risk        │ User        │ Parallel    │ Train-the-  │ Success         │
│ assessment  │ provisioning│ run         │ trainer     │ review          │
└─────────────┴─────────────┴─────────────┴─────────────┴─────────────────┘

Phases#

Phase 1: Kickoff (1 week)#

Agents: business-analyst, project-manager

Align all stakeholders and establish the implementation foundation.

Tasks:

Conduct kickoff meeting
Identify all stakeholders and roles
Define success criteria and metrics
Create detailed project plan
Establish communication cadence
Assess risks and dependencies

Kickoff Meeting Agenda:

## Enterprise Implementation Kickoff

### Attendees
- Customer: Executive Sponsor, Project Lead, IT Lead, Key Users
- Vendor: Account Manager, Implementation Lead, Technical Lead

### Agenda (90 minutes)

1. **Introductions** (10 min)
   - Team introductions and roles
   - Communication preferences

2. **Success Criteria Review** (15 min)
   - Review goals from sales process
   - Confirm success metrics
   - Align on expected outcomes

3. **Project Scope** (20 min)
   - Features to be implemented
   - Users to be onboarded
   - Integrations required
   - Out of scope items

4. **Timeline Review** (15 min)
   - Phase-by-phase timeline
   - Key milestones and deadlines
   - Dependencies and risks

5. **Technical Requirements** (15 min)
   - SSO configuration
   - Data migration needs
   - Integration requirements
   - Security requirements

6. **Resource Commitment** (10 min)
   - Customer resources needed
   - Vendor resources assigned
   - Decision-making authority

7. **Next Steps** (5 min)
   - Immediate action items
   - Next meeting schedule
   - Documentation to provide

Project Plan Template:

// lib/implementation/project-plan.ts

interface ImplementationProject {
  customer: string;
  startDate: Date;
  targetGoLive: Date;
  phases: Phase[];
  stakeholders: Stakeholder[];
  risks: Risk[];
  successCriteria: SuccessCriterion[];
}

interface Phase {
  name: string;
  startDate: Date;
  endDate: Date;
  milestones: Milestone[];
  tasks: Task[];
  dependencies: string[];
}

interface Task {
  id: string;
  name: string;
  owner: 'customer' | 'vendor';
  assignee: string;
  duration: number; // days
  dependencies: string[];
  status: 'not_started' | 'in_progress' | 'blocked' | 'complete';
}

const sampleProject: ImplementationProject = {
  customer: "Acme Corp",
  startDate: new Date("2024-03-01"),
  targetGoLive: new Date("2024-05-15"),
  phases: [
    {
      name: "Kickoff",
      startDate: new Date("2024-03-01"),
      endDate: new Date("2024-03-08"),
      milestones: [
        { name: "Kickoff complete", date: new Date("2024-03-04") },
        { name: "Project plan approved", date: new Date("2024-03-08") }
      ],
      tasks: [
        {
          id: "K1",
          name: "Schedule kickoff meeting",
          owner: "vendor",
          assignee: "Implementation Lead",
          duration: 1,
          dependencies: [],
          status: "complete"
        },
        {
          id: "K2",
          name: "Provide technical requirements",
          owner: "customer",
          assignee: "IT Lead",
          duration: 3,
          dependencies: ["K1"],
          status: "in_progress"
        }
      ],
      dependencies: []
    },
    // ... more phases
  ],
  successCriteria: [
    {
      metric: "User adoption",
      target: "90% of licensed users active within 30 days",
      measurement: "Weekly active users / licensed users"
    },
    {
      metric: "Data migration",
      target: "100% of historical data migrated accurately",
      measurement: "Record count validation and sampling"
    }
  ]
};

Phase 2: Setup & Configuration (2-3 weeks)#

Agents: backend-expert, devops-expert, security-expert

Provision and configure the customer's environment.

Tasks:

Provision dedicated environment
Configure SSO/SAML integration
Set up integrations (API, webhooks)
Configure RBAC and permissions
Provision initial users
Apply customer-specific settings

SSO Configuration Checklist:

## SSO Configuration Steps

### Pre-requisites
- [ ] Customer provides IdP metadata URL or XML
- [ ] Identify SSO admin contact
- [ ] Determine user attribute mapping

### Configuration
- [ ] Create SSO connection in admin panel
- [ ] Upload IdP metadata
- [ ] Configure attribute mapping:
  - [ ] Email (required)
  - [ ] First name
  - [ ] Last name
  - [ ] Department (optional)
  - [ ] Role (optional)
- [ ] Set up JIT provisioning rules
- [ ] Configure default role for new users

### Testing
- [ ] Test IdP-initiated login
- [ ] Test SP-initiated login
- [ ] Verify user attributes populate correctly
- [ ] Test user provisioning
- [ ] Test with multiple user roles

### Go-Live
- [ ] Enable SSO for organization
- [ ] Disable password login (optional)
- [ ] Document login URL for users
- [ ] Provide troubleshooting guide

Integration Setup:

// lib/implementation/integrations.ts

interface IntegrationConfig {
  type: string;
  name: string;
  status: 'pending' | 'configured' | 'tested' | 'live';
  config: Record<string, unknown>;
  testResults?: TestResult[];
}

const integrationChecklist: IntegrationConfig[] = [
  {
    type: 'sso',
    name: 'Okta SSO',
    status: 'configured',
    config: {
      metadataUrl: 'https://acme.okta.com/app/xxx/sso/saml/metadata',
      attributeMapping: {
        email: 'user.email',
        firstName: 'user.firstName',
        lastName: 'user.lastName'
      }
    }
  },
  {
    type: 'crm',
    name: 'Salesforce',
    status: 'pending',
    config: {
      instanceUrl: 'https://acme.salesforce.com',
      apiVersion: 'v57.0',
      syncObjects: ['Account', 'Contact', 'Opportunity']
    }
  },
  {
    type: 'communication',
    name: 'Slack',
    status: 'tested',
    config: {
      workspaceId: 'T123456',
      channels: ['#product-updates', '#support'],
      notifications: ['new_user', 'critical_alert']
    }
  }
];

async function testIntegration(
  integration: IntegrationConfig
): Promise<TestResult> {
  // Run integration-specific tests
  switch (integration.type) {
    case 'sso':
      return testSSOIntegration(integration);
    case 'crm':
      return testCRMIntegration(integration);
    case 'communication':
      return testSlackIntegration(integration);
    default:
      throw new Error(`Unknown integration type: ${integration.type}`);
  }
}

Phase 3: Data Migration (2-4 weeks)#

Agents: database-expert, backend-expert

Migrate data from legacy systems with validation and verification.

Tasks:

Analyze source data structure
Design data mapping
Build migration scripts
Execute test migration
Validate migrated data
Run parallel systems (if needed)
Execute final migration

Data Migration Framework:

// lib/migration/framework.ts

interface MigrationPlan {
  source: {
    system: string;
    format: 'csv' | 'json' | 'api' | 'database';
    connection?: string;
  };
  entities: EntityMapping[];
  schedule: {
    testMigration: Date;
    parallelRun: { start: Date; end: Date };
    finalMigration: Date;
    cutover: Date;
  };
  validation: ValidationRule[];
}

interface EntityMapping {
  sourceEntity: string;
  targetEntity: string;
  fieldMappings: FieldMapping[];
  transformations: Transformation[];
  estimatedRecords: number;
}

interface FieldMapping {
  source: string;
  target: string;
  type: 'direct' | 'transform' | 'default' | 'lookup';
  transformer?: string;
  defaultValue?: unknown;
  lookupTable?: string;
}

// Example migration plan
const migrationPlan: MigrationPlan = {
  source: {
    system: 'Legacy CRM',
    format: 'api',
    connection: 'https://legacy.acme.com/api'
  },
  entities: [
    {
      sourceEntity: 'customers',
      targetEntity: 'organizations',
      estimatedRecords: 5000,
      fieldMappings: [
        { source: 'customer_id', target: 'legacyId', type: 'direct' },
        { source: 'company_name', target: 'name', type: 'direct' },
        { source: 'industry_code', target: 'industry', type: 'lookup', lookupTable: 'industry_mapping' },
        { source: 'created_date', target: 'createdAt', type: 'transform', transformer: 'parseDate' }
      ],
      transformations: [
        {
          type: 'deduplicate',
          field: 'name',
          strategy: 'keep_newest'
        }
      ]
    },
    {
      sourceEntity: 'users',
      targetEntity: 'users',
      estimatedRecords: 500,
      fieldMappings: [
        { source: 'email', target: 'email', type: 'direct' },
        { source: 'full_name', target: 'name', type: 'direct' },
        { source: 'role', target: 'roleId', type: 'lookup', lookupTable: 'role_mapping' },
        { source: null, target: 'authMethod', type: 'default', defaultValue: 'sso' }
      ],
      transformations: []
    }
  ],
  validation: [
    {
      type: 'count',
      description: 'Record counts match',
      check: 'source.count === target.count'
    },
    {
      type: 'sample',
      description: 'Sample records match',
      sampleSize: 100,
      fields: ['name', 'email', 'createdAt']
    },
    {
      type: 'referential',
      description: 'All foreign keys valid',
      check: 'all organization references exist'
    }
  ]
};

Migration Execution Script:

// lib/migration/executor.ts

import { prisma } from '@/lib/prisma';

export async function executeMigration(
  plan: MigrationPlan,
  options: { dryRun: boolean; batchSize: number }
): Promise<MigrationResult> {
  const result: MigrationResult = {
    startTime: new Date(),
    entities: [],
    errors: [],
    warnings: []
  };

  for (const entity of plan.entities) {
    console.log(`Migrating ${entity.sourceEntity}...`);

    const entityResult = await migrateEntity(entity, options);
    result.entities.push(entityResult);

    if (entityResult.errors.length > 0) {
      result.errors.push(...entityResult.errors);
    }
  }

  // Run validation
  for (const rule of plan.validation) {
    const validationResult = await runValidation(rule);
    if (!validationResult.passed) {
      result.errors.push({
        type: 'validation',
        rule: rule.description,
        details: validationResult.details
      });
    }
  }

  result.endTime = new Date();
  result.success = result.errors.length === 0;

  return result;
}

async function migrateEntity(
  entity: EntityMapping,
  options: { dryRun: boolean; batchSize: number }
): Promise<EntityMigrationResult> {
  let processed = 0;
  let created = 0;
  let updated = 0;
  let errors: MigrationError[] = [];

  // Fetch source data in batches
  let offset = 0;
  while (true) {
    const sourceRecords = await fetchSourceBatch(
      entity.sourceEntity,
      options.batchSize,
      offset
    );

    if (sourceRecords.length === 0) break;

    for (const record of sourceRecords) {
      try {
        // Apply field mappings
        const transformed = applyMappings(record, entity.fieldMappings);

        // Apply transformations
        const final = applyTransformations(transformed, entity.transformations);

        if (!options.dryRun) {
          // Upsert to target
          await prisma[entity.targetEntity].upsert({
            where: { legacyId: record.id },
            update: final,
            create: final
          });
        }

        processed++;
        created++; // or updated based on upsert result
      } catch (error) {
        errors.push({
          sourceId: record.id,
          error: error.message,
          record: record
        });
      }
    }

    offset += options.batchSize;
    console.log(`  Processed ${processed} / ${entity.estimatedRecords}`);
  }

  return { entity: entity.sourceEntity, processed, created, updated, errors };
}

Phase 4: Training (1 week)#

Agents: technical-writer, ui-ux-expert

Train administrators and end users on the new system.

Tasks:

Develop training materials
Conduct admin training sessions
Conduct end-user training sessions
Create self-service documentation
Implement train-the-trainer program

Training Plan:

## Training Program

### Administrator Training (4 hours)

**Audience:** IT admins, team leads

**Topics:**
1. Admin console overview (30 min)
   - Navigation and settings
   - User management
   - Role and permission configuration

2. SSO and access management (45 min)
   - User provisioning
   - SSO troubleshooting
   - Access reviews

3. Security and compliance (45 min)
   - Audit log access
   - Security settings
   - Data export and retention

4. Integrations (30 min)
   - API overview
   - Webhook configuration
   - Third-party integrations

5. Support and escalation (30 min)
   - Support channels
   - Escalation procedures
   - Self-service resources

6. Hands-on exercises (60 min)
   - Create user accounts
   - Configure roles
   - Set up integrations

### End-User Training (2 hours)

**Audience:** All users

**Topics:**
1. Getting started (30 min)
   - Logging in (SSO)
   - Profile setup
   - Navigation overview

2. Core workflows (60 min)
   - [Primary use case walkthrough]
   - [Secondary use case walkthrough]
   - Tips and shortcuts

3. Collaboration features (20 min)
   - Sharing and permissions
   - Comments and notifications
   - Team features

4. Q&A and practice (10 min)

### Self-Service Resources

- Video library (10 short how-to videos)
- Interactive product tour
- Help center articles
- Quick reference card (PDF)
- FAQ document

Training Materials Checklist:

## Training Materials Inventory

### Videos
- [ ] Welcome and overview (5 min)
- [ ] Getting started tutorial (10 min)
- [ ] Feature deep-dive: [Feature 1] (8 min)
- [ ] Feature deep-dive: [Feature 2] (8 min)
- [ ] Admin console walkthrough (15 min)
- [ ] Integration setup guide (10 min)

### Documents
- [ ] Quick start guide (2 pages)
- [ ] User manual (full documentation)
- [ ] Admin guide
- [ ] API documentation
- [ ] FAQ document
- [ ] Troubleshooting guide

### Interactive
- [ ] Product tour (in-app)
- [ ] Sandbox environment
- [ ] Practice exercises
- [ ] Knowledge check quiz

### Customer-Specific
- [ ] Custom workflow documentation
- [ ] Integration configuration guide
- [ ] Role-specific guides

Phase 5: Go-Live & Handoff (1-2 weeks)#

Agents: devops-expert, business-analyst

Execute staged rollout and transition to ongoing support.

Tasks:

Execute staged user rollout
Monitor system performance
Provide hypercare support
Conduct go-live review
Hand off to Customer Success
Document lessons learned

Go-Live Checklist:

## Go-Live Readiness Checklist

### Technical Readiness
- [ ] All integrations tested and working
- [ ] SSO tested with production IdP
- [ ] Data migration complete and validated
- [ ] Performance tested under expected load
- [ ] Backup and recovery verified
- [ ] Monitoring and alerting configured

### User Readiness
- [ ] All users provisioned
- [ ] Admin training complete
- [ ] End-user training complete
- [ ] Support documentation available
- [ ] Communication sent to users

### Support Readiness
- [ ] Support team briefed on customer
- [ ] Escalation path defined
- [ ] Customer success manager assigned
- [ ] First business review scheduled

### Business Readiness
- [ ] Success criteria confirmed
- [ ] Metrics baseline established
- [ ] Executive sponsor sign-off
- [ ] Go/no-go decision made

Staged Rollout Plan:

// lib/implementation/rollout.ts

interface RolloutPlan {
  waves: RolloutWave[];
  rollbackCriteria: string[];
  successCriteria: string[];
}

interface RolloutWave {
  name: string;
  startDate: Date;
  users: UserGroup;
  percentage: number;
  duration: number; // days before next wave
  checkpoints: string[];
}

const rolloutPlan: RolloutPlan = {
  waves: [
    {
      name: "Pilot",
      startDate: new Date("2024-05-01"),
      users: { type: "selected", ids: ["user1", "user2", "user3"] },
      percentage: 5,
      duration: 3,
      checkpoints: [
        "No critical bugs reported",
        "Core workflows functional",
        "Performance acceptable"
      ]
    },
    {
      name: "Early Adopters",
      startDate: new Date("2024-05-04"),
      users: { type: "department", value: "Engineering" },
      percentage: 20,
      duration: 5,
      checkpoints: [
        "No P1 issues",
        "User satisfaction > 3.5/5",
        "Support ticket volume manageable"
      ]
    },
    {
      name: "General Availability",
      startDate: new Date("2024-05-09"),
      users: { type: "all" },
      percentage: 100,
      duration: 0,
      checkpoints: [
        "All success criteria met",
        "Support team comfortable",
        "No rollback needed"
      ]
    }
  ],
  rollbackCriteria: [
    "Critical data loss or corruption",
    "Security vulnerability discovered",
    "More than 20% of users unable to work",
    "Integration failure impacting business"
  ],
  successCriteria: [
    "90% of users active within 30 days",
    "Average login time < 3 seconds",
    "Support tickets < 5 per 100 users/week",
    "NPS > 30 at 60 days"
  ]
};

Hypercare Support Plan:

## Hypercare Support (First 2 Weeks Post Go-Live)

### Coverage
- **Hours:** Extended support (6 AM - 9 PM customer timezone)
- **Response SLA:**
  - P1 (critical): 15 minutes
  - P2 (high): 1 hour
  - P3 (medium): 4 hours

### Daily Activities
- Morning check-in with customer IT
- Review overnight logs and alerts
- Proactive outreach to pilot users
- End-of-day status summary

### Escalation Path
1. Implementation Support Engineer
2. Implementation Lead
3. Engineering On-Call
4. VP of Customer Success

### Transition to BAU Support
- Day 10: Review support metrics
- Day 12: Handoff meeting with CS team
- Day 14: Transition to standard support SLAs

Starting the Workflow#

# Start implementation workflow
bootspring workflow start enterprise-implementation

# Create project plan
bootspring enterprise implementation plan --customer "Acme Corp"

# Track implementation progress
bootspring enterprise implementation status

# Generate status report
bootspring enterprise implementation report

Deliverables#

A successful Enterprise Implementation workflow produces:

Signed project plan with timeline
Configured production environment
Completed SSO/integration setup
Migrated and validated data
Trained administrators and users
Training documentation
Go-live sign-off
Customer success handoff document

Success Metrics#

Metric	Target	Measurement
On-time delivery	90%	Go-live within 10% of planned date
Data accuracy	99.9%	Sample validation post-migration
User adoption	90%+	Active users at 30 days
Time to value	< 60 days	First business outcome achieved
Customer satisfaction	> 4/5	Post-implementation survey
Support tickets	< 5/100 users	First 30 days

Best Practices#

Over-communicate - Weekly status updates, clear escalation
Document everything - Decisions, configurations, issues
Test thoroughly - Integration testing, load testing, UAT
Plan for the unexpected - Buffer time, rollback plans
Involve the customer - They know their business best
Celebrate milestones - Build momentum and partnership

Common Pitfalls#

Underestimating data migration complexity
Insufficient stakeholder involvement
Skipping user acceptance testing
Poor change management
Inadequate training
No success criteria defined upfront