superglue offers multiple interfaces for different workflows. Choose based on your use case, team, and deployment requirements.

​
Quick Decision Guide

Use UI/Chat When

✅ Prototyping new integrations✅ Exploring APIs and data sources✅ Testing integration ideas quickly✅ Collaborating with non-technical users✅ Learning what’s possible with an API✅ One-off data extraction / analysis tasks

Use MCP/SDK When

✅ Production deployments✅ Automated workflows and pipelines✅ Custom error handling and retry logic✅ Integration with existing systems✅ CI/CD and version control✅ Scale and performance requirements

​
UI/Chat Interface Deep Dive

​
What Makes It Powerful

The UI/Chat interface is like having a data engineer AI assistant that understands APIs:
Instead of reading API docs and writing code:Traditional approach:
# Research Stripe API
curl -X GET https://api.stripe.com/v1/customers \
  -H "Authorization: Bearer sk_test_..." \
  -G -d limit=100 -d created[gt]=1640995200

# Write transformation code
jq '.data[] | {id: .id, email: .email, ...}'

# Handle pagination
# Handle errors  
# Format output
superglue UI approach:
“Get all Stripe customers created in 2024, show me their email, subscription status, and total revenue”
That’s it. superglue handles the API calls, pagination, transformations, and formatting.

​
Best UI/Chat Use Cases

​
SDK Deep Dive

​
Production-Grade Features

Programmatic Control

// Full control over execution
const result = await superglue.executeWorkflow({
  instruction: "Daily customer sync",
  integrationIds: ["stripe", "hubspot"],
  options: {
    timeout: 300000, // 5 minutes
    retries: 3,
    retryDelay: 5000
  }
});

Error Handling

try {
  const result = await superglue.executeWorkflow({
    workflowId: "customer-sync"
  });
  
  if (!result.success) {
    await alerting.sendAlert({
      severity: "warning",
      message: `Workflow failed: ${result.error}`,
      workflow: "customer-sync"
    });
  }
} catch (error) {
  await alerting.sendAlert({
    severity: "critical", 
    message: `System error: ${error.message}`
  });
}

Integration Patterns

// Integrate with existing systems
class DataPipeline {
  async runDailySync() {
    const workflows = [
      "stripe-customer-sync",
      "hubspot-deal-sync", 
      "analytics-update"
    ];
    
    for (const workflowId of workflows) {
      await this.executeWithMetrics(workflowId);
    }
  }
  
  private async executeWithMetrics(workflowId: string) {
    const startTime = Date.now();
    const result = await superglue.executeWorkflow({
      id: workflowId,
      credentials: await this.getCredentials()
    });
    
    await metrics.recordExecution({
      workflow: workflowId,
      duration: Date.now() - startTime,
      success: result.success,
      recordCount: result.data?.recordCount || 0
    });
    
    return result;
  }
}

CI/CD Integration

# GitHub Actions workflow
name: Deploy Data Pipelines
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Test Workflows
        run: |
          npm install @superglue/client
          npm run test-workflows
      - name: Deploy to Production
        run: |
          node scripts/deploy-workflows.js
        env:
          SUPERGLUE_API_KEY: ${{ secrets.SUPERGLUE_API_KEY }}

​
SDK Use Cases

​
Migration Path: UI to SDK

​
Phase 1: Prototype in UI

1

Start with Natural Language

Use the UI to rapidly prototype and test your integration: > “Get all Salesforce opportunities closed this month with contact details”
2

Refine and Test

Iterate on the query until you get exactly the data you need: > “Actually, I need opportunities over $10k with the primary contact’s email and phone”
3

Save the Workflow

Once it works perfectly: > “Save this as ‘monthly-sales-report‘“

​
Phase 2: Productionize with SDK

1

Export Workflow Definition

// Get the workflow definition from UI
const workflow = await superglue.getWorkflow("monthly-sales-report");
console.log(JSON.stringify(workflow, null, 2));
2

Add Production Features

// Add error handling, monitoring, etc.
class SalesReportGenerator {
  async generateMonthlyReport() {
    try {
      const result = await superglue.executeWorkflow({
        workflowId: "monthly-sales-report",
        credentials: await this.getCredentials(),
        options: {
          timeout: 300000,
          retries: 2,
          webhookUrl: this.webhookUrl
        }
      });
      
      if (result.success) {
        await this.sendReportToStakeholders(result.data);
        await this.logSuccess(result);
      } else {
        await this.handleError(result.error);
      }
    } catch (error) {
      await this.handleCriticalError(error);
    }
  }
}
3

Deploy and Monitor

// Schedule and monitor
const scheduler = new WorkflowScheduler({
  workflows: [
    {
      id: "monthly-sales-report",
      schedule: "0 9 1 * *", // 9 AM on 1st of month
      generator: new SalesReportGenerator()
    }
  ],
  monitoring: {
    alertsChannel: "#data-alerts",
    metricsEndpoint: "/metrics/workflows"
  }
});

​
Team Collaboration Patterns

Business Analyst (using UI):
“I need a report showing customer churn patterns from our subscription data”
Creates and tests the workflow in UIData Engineer (using SDK):
// Takes the validated workflow and productionizes it
const churnAnalysis = new ChurnAnalysisWorkflow({
  workflowId: "customer-churn-analysis", // From BA's work
  schedule: "weekly",
  alerting: true,
  outputFormat: "dashboard"
});

​
Performance Considerations

UI/Chat Performance

Optimized for:
  • Interactive response times (< 30 seconds)
  • Small to medium datasets (< 10k records)
  • Exploratory workflows
  • Real-time feedback
Limitations:
  • Not suitable for large batch processing
  • No parallel execution control
  • Limited customization of timeouts/retries

SDK Performance

Optimized for:
  • Large datasets (millions of records)
  • Parallel workflow execution
  • Custom timeout and retry strategies
  • Webhook-based async processing
Example:
// Process large dataset with custom settings
const result = await superglue.executeWorkflow({
  workflowId: "large-data-sync",
  options: {
    timeout: 1800000, // 30 minutes
    async: true, // Use webhooks for completion
    batchSize: 1000, // Process in batches
    parallelism: 5 // Run 5 batches in parallel
  }
});

​
Cost Optimization

Use UI/Chat for cost-effective development:
  • Rapid prototyping without engineering time
  • Validate integrations before committing to development
  • Business stakeholders can test ideas directly
  • Reduce back-and-forth between business and engineering

​
Next Steps

Try Both Approaches

Start with the UI to prototype your first integration, then see how to productionize it with the SDK

API Ranking Benchmark

See concrete performance comparisons between superglue and traditional approaches

Data Pipeline Patterns

Learn common patterns for different types of data integration projects

Production Examples

See real examples of UI workflows productionized with the SDK