Building an AI-First Startup: Strategic Implementation Guide for Founders and Technical Leaders

The landscape of modern startups has fundamentally shifted. While previous generations of entrepreneurs built companies that eventually adopted AI capabilities, today's most successful startups are architected from the ground up to be AI-native. This isn't merely about integrating machine learning models into existing workflows—it's about reimagining how companies operate, scale, and create value when artificial intelligence becomes the core differentiator.

For technical founders and engineering leaders, building an AI-first startup presents unique challenges that span strategic planning, technical architecture, team composition, and operational excellence. Unlike traditional software companies that can retrofit AI capabilities, AI-first startups must solve complex problems around data infrastructure, model operations, and intelligent product experiences from day one.

This comprehensive guide provides a strategic framework for founders and technical leaders who are building AI-native companies. We'll explore how to establish the right mindset, architect scalable technical systems, build effective teams, and measure success in an AI-driven organization.

The AI-First Mindset: Redefining Startup Strategy

Define AI-first vs AI-enabled Business Models

The distinction between AI-first and AI-enabled businesses lies in how deeply artificial intelligence is woven into the company's value proposition and operational DNA. AI-enabled companies use machine learning to optimize existing processes—think of a traditional e-commerce platform that adds recommendation engines or a SaaS tool that incorporates chatbot support. These implementations improve existing workflows but don't fundamentally change the business model.

AI-first startups, by contrast, cannot exist without artificial intelligence. Their core value proposition depends entirely on AI capabilities. Consider companies like Notion's AI-powered content generation, where the intelligence layer enables entirely new user workflows, or Linear's AI-driven project management features that transform how development teams operate. These companies didn't add AI features—they built their entire product experience around intelligent automation.

For founders, this distinction has profound strategic implications. AI-first companies must prioritize data collection and model development as primary business activities, not secondary optimization tasks. Every product decision, engineering sprint, and hiring choice should be evaluated through the lens of how it strengthens the company's AI capabilities and competitive moat.

Map Data as Your Primary Competitive Moat

In AI-first startups, data becomes the most critical competitive advantage. Unlike traditional software companies where features and user experience create defensibility, AI-native companies build moats through proprietary datasets and the intelligence derived from them.

This requires a fundamental shift in how founders think about data strategy. Every user interaction, system event, and business transaction should be designed to generate valuable training data. The key is building systems that create positive feedback loops—where better data leads to improved AI performance, which attracts more users, generating higher-quality data.

Successful AI-first companies design their entire customer journey around data collection. They create experiences that naturally encourage users to provide the rich, contextual information needed to train increasingly sophisticated models. This isn't about invasive data collection, but about building products where users are incentivized to share information because it directly improves their experience.

Build Decision-Making Frameworks That Prioritize Algorithmic Solutions

AI-first organizations operate differently from traditional startups because they must constantly evaluate whether problems should be solved through rules-based systems, human processes, or machine learning approaches. This requires establishing clear decision-making frameworks that help teams identify when AI solutions provide the most value.

The framework should consider factors like data availability, problem complexity, scalability requirements, and explainability needs. Simple rule-based systems might be appropriate for straightforward logic, while complex pattern recognition problems demand sophisticated ML approaches. The key is avoiding the common trap of applying AI to every problem without considering whether it's the most effective solution.

Teams should also develop intuition around when to build custom AI solutions versus leveraging existing models and APIs. Many AI-first startups waste valuable resources building proprietary solutions for problems that commodity AI services solve effectively.

Design Customer Acquisition Strategies Around Intelligent User Experiences

Traditional startup growth strategies often focus on optimizing conversion funnels and reducing customer acquisition costs through better targeting. AI-first companies must think about growth differently, designing acquisition strategies that showcase their intelligent capabilities from the first user interaction.

This means creating onboarding experiences that demonstrate AI value immediately, rather than requiring users to invest significant time before experiencing intelligent features. The goal is making the AI capabilities feel magical and essential, not optional or supplementary.

Successful AI-first companies also design viral growth mechanisms around their AI features. Users naturally want to share experiences that feel intelligent and personalized. Building shareable AI outputs and collaborative features can create organic growth loops that traditional companies struggle to replicate.

Establish Data Collection Strategies That Compound Value Over Time

The most successful AI-first startups build data collection strategies that create compounding returns. Early data improves model performance, which attracts more sophisticated users, who generate higher-quality data, enabling even better models. This creates a flywheel effect that becomes increasingly difficult for competitors to replicate.

This requires careful planning around data schema design, user privacy considerations, and feedback loop optimization. Companies must balance aggressive data collection with user trust and regulatory compliance, while ensuring that data quality remains high as volume scales.

Technical Architecture for AI-Native Startups

Design Microservices Architecture with ML Pipeline Integration Points

Building AI-first systems requires architectural decisions that support both traditional application logic and machine learning workflows. The most effective approach involves designing microservices that can seamlessly integrate with ML pipelines while maintaining system reliability and scalability.

The architecture should separate concerns between data ingestion, feature engineering, model serving, and application logic, while ensuring these components can communicate efficiently. This typically involves event-driven architectures that can handle both real-time inference requests and batch processing workflows.

// Event-driven ML feature collection system with Redis and TypeScript
import Redis from 'ioredis';
import { EventEmitter } from 'events';

interface UserEvent {
  userId: string;
  eventType: 'page_view' | 'click' | 'purchase' | 'search';
  timestamp: number;
  properties: Record<string, any>;
  sessionId: string;
}

interface FeatureVector {
  userId: string;
  features: Record<string, number>;
  computedAt: number;
}

class MLFeatureCollector extends EventEmitter {
  private redis: Redis;
  private featureWindow: number = 3600000; // 1 hour in ms

  constructor(redisUrl: string) {
    super();
    this.redis = new Redis(redisUrl, {
      retryDelayOnFailover: 100,
      maxRetriesPerRequest: 3,
      lazyConnect: true,
    });
    
    this.redis.on('error', (error) => {
      console.error('Redis connection error:', error);
      this.emit('error', error);
    });
  }

  async collectEvent(event: UserEvent): Promise<void> {
    try {
      // Store raw event for batch processing
      await this.redis.zadd(
        `events:${event.userId}`,
        event.timestamp,
        JSON.stringify(event)
      );

      // Update real-time feature counters
      const features = await this.computeRealTimeFeatures(event);
      await this.updateFeatureStore(event.userId, features);

      // Trigger downstream ML pipeline
      await this.redis.publish('ml_events', JSON.stringify({
        type: 'feature_update',
        userId: event.userId,
        features,
        timestamp: Date.now()
      }));

      this.emit('featureUpdated', { userId: event.userId, features });
    } catch (error) {
      console.error('Failed to collect event:', error);
      this.emit('error', error);
      throw error;
    }
  }

  private async computeRealTimeFeatures(event: UserEvent): Promise<Record<string, number>> {
    const windowStart = event.timestamp - this.featureWindow;
    
    try {
      // Get recent events within time window
      const recentEvents = await this.redis.zrangebyscore(
        `events:${event.userId}`,
        windowStart,
        event.timestamp,
        'WITHSCORES'
      );

      const features: Record<string, number> = {
        event_count_1h: recentEvents.length / 2, // WITHSCORES returns [value, score] pairs
        session_duration: 0,
        unique_event_types: 0,
        last_purchase_hours_ago: -1,
      };

      // Compute session duration
      if (recentEvents.length >= 2) {
        const firstEventTime = parseFloat(recentEvents[1]);
        features.session_duration = (event.timestamp - firstEventTime) / 1000;
      }

      // Count unique event types
      const eventTypes = new Set();
      for (let i = 0; i < recentEvents.length; i += 2) {
        const eventData = JSON.parse(recentEvents[i]) as UserEvent;
        eventTypes.add(eventData.eventType);
      }
      features.unique_event_types = eventTypes.size;

      // Find time since last purchase
      const purchases = recentEvents.filter((_, index) => {
        if (index % 2 === 1) return false; // Skip scores
        const eventData = JSON.parse(recentEvents[index]) as UserEvent;
        return eventData.eventType === 'purchase';
      });

      if (purchases.length > 0) {
        const lastPurchase = JSON.parse(purchases[purchases.length - 1]) as UserEvent;
        features.last_purchase_hours_ago = (event.timestamp - lastPurchase.timestamp) / 3600000;
      }

      return features;
    } catch (error) {
      console.error('Error computing real-time features:', error);
      throw error;
    }
  }

  private async updateFeatureStore(userId: string, features: Record<string, number>): Promise<void> {
    const featureVector: FeatureVector = {
      userId,
      features,
      computedAt: Date.now()
    };

    try {
      await this.redis.hset(
        'feature_store',
        userId,
        JSON.stringify(featureVector)
      );

      // Set TTL for feature cleanup
      await this.redis.expire(`events:${userId}`, 86400); // 24 hours
    } catch (error) {
      console.error('Failed to update feature store:', error);
      throw error;
    }
  }

  async getFeatures(userId: string): Promise<FeatureVector | null> {
    try {
      const stored = await this.redis.hget('feature_store', userId);
      return stored ? JSON.parse(stored) : null;
    } catch (error) {
      console.error('Failed to retrieve features:', error);
      return null;
    }
  }

  async cleanup(): Promise<void> {
    await this.redis.quit();
  }
}

// Usage example
const featureCollector = new MLFeatureCollector('redis://localhost:6379');

featureCollector.on('featureUpdated', ({ userId, features }) => {
  console.log(`Updated features for user ${userId}:`, features);
});

featureCollector.on('error', (error) => {
  console.error('Feature collector error:', error);
});

Implement Event-Driven Data Collection Systems for Real-Time Learning

Real-time learning capabilities require sophisticated event-driven architectures that can capture, process, and act on data as it flows through the system. This involves building robust message queuing systems, stream processing capabilities, and real-time feature stores that support both online and offline learning scenarios.

The key is designing systems that can handle high-throughput data ingestion while maintaining data quality and consistency. This typically involves implementing back-pressure mechanisms, dead letter queues for failed events, and monitoring systems that can detect data quality issues in real-time.

Build Containerized ML Model Serving Infrastructure Using Kubernetes

Model serving infrastructure must handle the unique requirements of machine learning workloads, including variable computational demands, version management, and A/B testing capabilities. Kubernetes provides an excellent foundation for building scalable, reliable ML serving systems.

// Model serving API with health checks and performance monitoring
import express from 'express';
import prometheus from 'prom-client';
import { createHash } from 'crypto';

interface ModelPrediction {
  modelVersion: string;
  prediction: any;
  confidence: number;
  latency: number;
  requestId: string;
}

interface ModelLoadConfig {
  modelPath: string;
  version: string;
  warmupSamples?: number;
}

class ModelServingAPI {
  private app: express.Application;
  private models: Map<string, any> = new Map();
  private metrics: {
    requestCount: prometheus.Counter;
    requestDuration: prometheus.Histogram;
    modelAccuracy: prometheus.Gauge;
    errorRate: prometheus.Counter;
  };

  constructor(private port: number = 8080) {
    this.app = express();
    this.setupMetrics();
    this.setupMiddleware();
    this.setupRoutes();
  }

  private setupMetrics(): void {
    // Create Prometheus metrics
    this.metrics = {
      requestCount: new prometheus.Counter({
        name: 'ml_requests_total',
        help: 'Total number of ML prediction requests',
        labelNames: ['model', 'version', 'status']
      }),
      
      requestDuration: new prometheus.Histogram({
        name: 'ml_request_duration_seconds',
        help: 'Duration of ML prediction requests',
        labelNames: ['model', 'version'],
        buckets: [0.01, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0]
      }),
      
      modelAccuracy: new prometheus.Gauge({
        name: 'ml_model_accuracy',
        help: 'Current model accuracy score',
        labelNames: ['model', 'version']
      }),
      
      errorRate: new prometheus.Counter({
        name: 'ml_errors_total',
        help: 'Total number of ML prediction errors',
        labelNames: ['model', 'version', 'error_type']
      })
    };

    // Register default metrics
    prometheus.register.registerMetric(this.metrics.requestCount);
    prometheus.register.registerMetric(this.metrics.requestDuration);
    prometheus.register.registerMetric(this.metrics.modelAccuracy);
    prometheus.register.registerMetric(this.metrics.errorRate);
  }

  private setupMiddleware(): void {
    this.app.use(express.json({ limit: '10mb' }));
    this.app.use(express.urlencoded({ extended: true }));
    
    // Request logging middleware
    this.app.use((req, res, next) => {
      const requestId = createHash('md5')
        .update(`${Date.now()}-${Math.random()}`)
        .digest('hex')
        .substring(0, 8);
      
      req.headers['x-request-id'] = requestId;
      console.log(`[${requestId}] ${req.method} ${req.path}`);
      next();
    });

    // Error handling middleware
    this.app.use((error: Error, req: express.Request, res: express.Response, next: express.NextFunction) => {
      console.error(`Request error: ${error.message}`);
      this.metrics.errorRate.inc({
        model: req.params.modelName || 'unknown',
        version: req.headers['model-version'] || 'unknown',
        error_type: 'server_error'
      });
      
      res.status(500).json({
        error: 'Internal server error',
        requestId: req.headers['x-request-id']
      });
    });
  }

  private setupRoutes(): void {
    // Health check endpoint
    this.app.get('/health', (req, res) => {
      const health = {
        status: 'healthy',
        timestamp: new Date().toISOString(),
        models: Array.from(this.models.keys()),
        uptime: process.uptime()
      };
      res.json(health);
    });

    // Metrics endpoint for Prometheus
    this.app.get('/metrics', async (req, res) => {
      try {
        res.set('Content-Type', prometheus.register.contentType);
        res.end(await prometheus.register.metrics());
      } catch (error) {
        console.error('Error generating metrics:', error);
        res.status(500).end();
      }
    });

    // Model prediction endpoint
    this.app.post('/predict/:modelName', async (req, res) => {
      const startTime = Date.now();
      const { modelName } = req.params;
      const modelVersion = req.headers['model-version'] as string || 'latest';
      const requestId = req.headers['x-request-id'] as string;

      try {
        if (!this.models.has(modelName)) {
          this.metrics.errorRate.inc({
            model: modelName,
            version: modelVersion,
            error_type: 'model_not_found'
          });
          
          return res.status(404).json({
            error: `Model ${modelName} not found`,
            requestId
          });
        }

        const model = this.models.get(modelName);
        const prediction = await this.makePrediction(model, req.body, modelVersion);
        
        const latency = Date.now() - startTime;
        
        // Record metrics
        this.metrics.requestCount.inc({
          model: modelName,
          version: modelVersion,
          status: 'success'
        });
        
        this.metrics.requestDuration.observe(
          { model: modelName, version: modelVersion },
          latency / 1000
        );

        const response: ModelPrediction = {
          modelVersion,
          prediction: prediction.result,
          confidence: prediction.confidence,
          latency,
          requestId
        };

        res.json(response);
      } catch (error) {
        const latency = Date.now() - startTime;
        
        this.metrics.errorRate.inc({
          model: modelName,
          version: modelVersion,
          error_type: 'prediction_error'
        });
        
        this.metrics.requestCount.inc({
          model: modelName,
          version: modelVersion,
          status: 'error'
        });

        console.error(`Prediction error for ${modelName}:`, error);
        
        res.status(500).json({
          error: 'Prediction failed',
          requestId,
          latency
        });
      }
    });

    // Model loading endpoint
    this.app.post('/models/:modelName/load', async (req, res) => {
      const { modelName } = req.params;
      const config: ModelLoadConfig = req.body;

      try {
        await this.loadModel(modelName, config);
        res.json({
          message: `Model ${modelName} loaded successfully`,
          version: config.version
        });
      } catch (error) {
        console.error(`Failed to load model ${modelName}:`, error);
        res.status(500).json({
          error: `Failed to load model ${modelName}`,
          details: error instanceof Error ? error.message : 'Unknown error'
        });
      }
    });
  }

  private async makePrediction(model: any, input: any, version: string): Promise<{ result: any; confidence: number }> {
    // Simulate model prediction - replace with actual ML model inference
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve({
          result: { classification: 'positive', score: 0.87 },
          confidence: 0.87
        });
      }, Math.random() * 100); // Simulate variable latency
    });
  }

  private async loadModel(modelName: string, config: ModelLoadConfig): Promise<void> {
    // Simulate model loading - replace with actual model loading logic
    console.log(`Loading model ${modelName} from ${config.modelPath}`);
    
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        if (Math.random() > 0.1) { // 90% success rate
          this.models.set(modelName, {
            version: config.version,
            path: config.modelPath,
            loadedAt: new Date()
          });
          
          // Update model accuracy metric (would come from validation data)
          this.metrics.modelAccuracy.set(
            { model: modelName, version: config.version },
            0.85 + Math.random() * 0.1
          );
          
          resolve();
        } else {
          reject(new Error('Simulated model loading failure'));
        }
      }, 2000 + Math.random() * 3000); // Simulate loading time
    });
  }

  public async start(): Promise<void> {
    return new Promise((resolve) => {
      this.app.listen(this.port, () => {
        console.log(`ML Model serving API running on port ${this.port}`);
        resolve();
      });
    });
  }
}

// Usage
const modelAPI = new ModelServingAPI(8080);
modelAPI.start().then(() => {
  console.log('Model serving API started successfully');
}).catch((error) => {
  console.error('Failed to start model serving API:', error);
});

Establish MLOps Workflows for Continuous Model Deployment and Monitoring

MLOps represents one of the most critical capabilities for AI-first startups, enabling teams to deploy, monitor, and iterate on machine learning models with the same reliability and velocity as traditional software deployments. This requires building automated pipelines that handle model training, validation, deployment, and rollback procedures.

Effective MLOps workflows include automated model testing, performance benchmarking, and gradual rollout mechanisms that minimize risk when deploying new model versions. Teams must also implement comprehensive logging and monitoring systems that can detect model performance degradation before it impacts users.

Create Feature Stores for Consistent Data Access Across Teams

Feature stores solve the critical problem of feature reusability and consistency across different models and teams. As AI-first companies scale, multiple teams often need access to similar features, and maintaining consistency becomes increasingly challenging without centralized feature management.

A well-designed feature store provides both online and offline feature access, handles feature versioning, and ensures data consistency across training and serving environments. This infrastructure investment pays significant dividends as teams scale and model complexity increases.

Design API-First Architecture to Support AI Model Integration

API-first architectures enable AI-first startups to experiment with different models and algorithms without requiring extensive system refactoring. This approach abstracts model implementation details behind consistent interfaces, allowing teams to swap models, implement A/B testing, and gradually migrate to new approaches.

The key is designing APIs that can handle the unique requirements of ML systems, including variable response times, confidence scores, and graceful degradation when models are unavailable.

Data Strategy and Infrastructure Foundation

Build Streaming Data Pipelines for Real-Time Feature Engineering

Real-time feature engineering represents one of the most technically challenging aspects of AI-first infrastructure. Unlike batch processing systems that can tolerate higher latency, real-time features must be computed and served with millisecond precision while maintaining accuracy and consistency.

Streaming data pipelines must handle out-of-order events, duplicate data, and system failures while ensuring that features remain consistent across different time windows and aggregation levels. This requires sophisticated stream processing frameworks and careful attention to state management and fault tolerance.

// Data pipeline orchestration using workflow management tools
import { EventEmitter } from 'events';

interface PipelineStep {
  name: string;
  dependencies: string[];
  execute: (input: any, context: PipelineContext) => Promise<any>;
  retryConfig: {
    maxRetries: number;
    backoffMultiplier: number;
    initialDelay: number;
  };
  timeout: number;
}

interface PipelineContext {
  runId: string;
  startTime: number;
  metadata: Record<string, any>;
  stepResults: Map<string, any>;
}

interface PipelineRun {
  id: string;
  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
  steps: Map<string, StepExecution>;
  startTime: number;
  endTime?: number;
  error?: string;
}

interface StepExecution {
  status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
  startTime?: number;
  endTime?: number;
  attempts: number;
  error?: string;
  result?: any;
}

class DataPipelineOrchestrator extends EventEmitter {
  private runs: Map<string, PipelineRun> = new Map();
  private steps: Map<string, PipelineStep> = new Map();

  constructor() {
    super();
  }

  registerStep(step: PipelineStep): void {
    this.steps.set(step.name, step);
    console.log(`Registered pipeline step: ${step.name}`);
  }

  async executeWorkflow(
    stepNames: string[],
    initialInput: any,
    metadata: Record<string, any> = {}
  ): Promise<string> {
    const runId = this.generateRunId();
    const run: PipelineRun = {
      id: runId,
      status: 'pending',
      steps: new Map(),
      startTime: Date.now()
    };

    // Initialize step executions
    stepNames.forEach(stepName => {
      run.steps.set(stepName, {
        status: 'pending',
        attempts: 0
      });
    });

    this.runs.set(runId, run);
    
    const context: PipelineContext = {
      runId,
      startTime: run.startTime,
      metadata,
      stepResults: new Map()
    };

    try {
      run.status = 'running';
      this.emit('workflowStarted', { runId, stepNames, metadata });

      const sortedSteps = this.topologicalSort(stepNames);
      await this.executeStepsInOrder(sortedSteps, initialInput, context);

      run.status = 'completed';
      run.endTime = Date.now();
      
      this.emit('workflowCompleted', {
        runId,
        duration: run.endTime - run.startTime,
        results: Object.fromEntries(context.stepResults)
      });

    } catch (error) {
      run.status = 'failed';
      run.endTime = Date.now();
      run.error = error instanceof Error ? error.message : 'Unknown error';
      
      this.emit('workflowFailed', {
        runId,
        error: run.error,
        duration: run.endTime - run.startTime
      });

      throw error;
    }

    return runId;
  }

  private async executeStepsInOrder(
    sortedSteps: string[],
    initialInput: any,
    context: PipelineContext
  ): Promise<void> {
    let currentInput = initialInput;

    for (const stepName of sortedSteps) {
      const run = this.runs.get(context.runId)!;
      const stepExecution = run.steps.get(stepName)!;
      const step = this.steps.get(stepName);

      if (!step) {
        throw new Error(`Step not found: ${stepName}`);
      }

      try {
        stepExecution.status = 'running';
        stepExecution.startTime = Date.now();
        
        this.emit('stepStarted', {
          runId: context.runId,
          stepName,
          attempt: stepExecution.attempts + 1
        });

        const result = await this.executeStepWithRetry(
          step,
          currentInput,
          context
        );

        stepExecution.status = 'completed';
        stepExecution.endTime = Date.now();
        stepExecution.result = result;
        context.stepResults.set(stepName, result);

        // Pass result to next step
        currentInput = result;

        this.emit('stepCompleted', {
          runId: context.runId,
          stepName,
          duration: stepExecution.endTime - stepExecution.startTime!,
          result
        });

      } catch (error) {
        stepExecution.status = 'failed';
        stepExecution.endTime = Date.now();
        stepExecution.error = error instanceof Error ? error.message : 'Unknown error';

        this.emit('stepFailed', {
          runId: context.runId,
          stepName,
          error: stepExecution.error,
          attempts: stepExecution.attempts
        });

        throw error;
      }
    }
  }

  private async executeStepWithRetry(
    step: PipelineStep,
    input: any,
    context: PipelineContext
  ): Promise<any> {
    const run = this.runs.get(context.runId)!;
    const stepExecution = run.steps.get(step.name)!;
    let lastError: Error | null = null;

    for (let attempt = 0; attempt <= step.retryConfig.maxRetries; attempt++) {
      stepExecution.attempts = attempt + 1;

      try {
        // Execute step with timeout
        const result = await Promise.race([
          step.execute(input, context),
          new Promise((_, reject) => 
            setTimeout(() => reject(new Error('Step execution timeout')), step.timeout)
          )
        ]);

        return result;

      } catch (error) {
        lastError = error instanceof Error ? error : new Error('Unknown error');
        
        console.error(
          `Step ${step.name} failed on attempt ${attempt + 1}/${step.retryConfig.maxRetries + 1}:`,
          lastError.message
        );

        if (attempt < step.retryConfig.maxRetries) {
          const delay = step.retryConfig.initialDelay * 
                       Math.pow(step.retryConfig.backoffMultiplier, attempt);
          
          console.log(`Retrying step ${step.name} in ${delay}ms`);
          await this.sleep(delay);
        }
      }
    }

    throw lastError;
  }

  private topologicalSort(stepNames: string[]): string[] {
    const visited = new Set<string>();
    const visiting = new Set<string>();
    const result: string[] = [];

    const visit = (stepName: string): void => {
      if (visiting.has(stepName)) {
        throw new Error(`Circular dependency detected involving step: ${stepName}`);
      }
      
      if (visited.has(stepName)) {
        return;
      }

      visiting.add(stepName);
      
      const step = this.steps.get(stepName);
      if (!step) {
        throw new Error(`Step not found: ${stepName}`);
      }

      // Visit all dependencies first
      step.dependencies.forEach(dep => {
        if (stepNames.includes(dep)) {
          visit(dep);
        }
      });

      visiting.delete(stepName);
      visited.add(stepName);
      result.push(stepName);
    };

    stepNames.forEach(stepName => {
      if (!visited.has(stepName)) {
        visit(stepName);
      }
    });

    return result;
  }

  private generateRunId(): string {
    return `run_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
  }

  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  getWorkflowStatus(runId: string): PipelineRun | undefined {
    return this.runs.get(runId);
  }

  async cancelWorkflow(runId: string): Promise<boolean> {
    const run = this.runs.get(runId);
    if (!run || run.status !== 'running') {
      return false;
    }

    run.status = 'cancelled';
    run.endTime = Date.now();
    
    this.emit('workflowCancelled', { runId });
    return true;
  }
}

// Example usage with data processing steps
const orchestrator = new DataPipelineOrchestrator();

// Register data processing steps
orchestrator.registerStep({
  name: 'extract_data',
  dependencies: [],
  timeout: 30000,
  retryConfig: { maxRetries: 2, backoffMultiplier: 2, initialDelay: 1000 },