Platform Capabilities: Infrastructure You Don’t Build

// Traditional Node.js orchestration
class WorkflowStateMachine {
  constructor() {
    this.db = new PostgreSQL();
    this.redis = new Redis();
    this.eventStore = new EventStore();
    this.kafka = new KafkaClient();
  }
  
  async execute(orderId) {
    // Step 1: Persist state before any operation
    const workflowState = {
      orderId,
      workflowId: uuidv4(),
      currentStep: "waiting_for_approval",
      data: {},
      version: 1,
      timestamp: Date.now(),
      status: "RUNNING"
    };
    
    await this.db.saveWorkflowState(workflowState);
    await this.redis.set(`workflow:${workflowState.workflowId}`, JSON.stringify(workflowState));
    
    // Step 2: Create approval task
    const taskId = await this.db.createTask({
      orderId,
      assignedTo: "manager",
      timeout: Date.now() + (24 * 60 * 60 * 1000),  // 24 hours
      type: "APPROVAL_REQUIRED"
    });
    
    // ⚠️ PROBLEM: How do you wait for hours/days/weeks?
    
    // Option A: Polling (BAD - wastes resources)
    while (true) {
      const task = await this.db.getTask(taskId);
      if (task.status === "completed") {
        break;
      }
      await sleep(60000); // Check every minute
      // ❌ Server must stay running continuously
      // ❌ Database hit every minute
      // ❌ Doesn't scale
    }
    
    // Option B: Event queue (COMPLEX - 200+ lines)
    await this.kafka.publish("task.created", {
      orderId,
      taskId,
      workflowId: workflowState.workflowId
    });
    
    // ⚠️ Separate consumer process needed (different codebase!)
    // ⚠️ Must reconstruct exact execution context
    // ⚠️ Need distributed locking to prevent concurrent updates
    // ⚠️ Complex error scenarios (message lost, duplicate delivery)
    
    // Option C: Database triggers (LIMITED - vendor lock-in)
    // ❌ Can't handle complex business logic
    // ❌ Hard to test and debug
    // ❌ PostgreSQL vs MySQL differences
    
    // You need to manually implement:
    // 1. State serialization/deserialization (100+ lines)
    //    - JSON encoding, versioning, schema evolution
    // 2. Event sourcing (200+ lines)
    //    - Event log, event replay, snapshots
    // 3. Crash recovery (150+ lines)
    //    - Detect crashed workflows, resume from last checkpoint
    // 4. Distributed locking (80+ lines)
    //    - Redis locks, deadlock detection, lease renewal
    // 5. Transaction management (120+ lines)
    //    - ACID guarantees, rollback, compensation
    // 6. Timeout handling (60+ lines)
    //    - TTL tracking, timeout callbacks, escalation
    // 7. Retry mechanisms (80+ lines)
    //    - Exponential backoff, error classification
    // 8. Webhook correlation (200+ lines)
    //    - UUID mapping, signature validation
    //
    // = ~990 lines of infrastructure code
  }
  
  // Separate webhook handler (DIFFERENT PROCESS/CODEBASE!)
  async handleTaskComplete(taskId, decision) {
    // ⚠️ How do we resume from the EXACT point?
    
    // 1. Load workflow state from database
    const state = await this.db.getWorkflowState({ taskId });
    if (!state) {
      throw new Error("Workflow state not found - data loss!");
    }
    
    // 2. Reconstruct execution context
    // ⚠️ Need to rebuild variables, local state, call stack
    const context = {
      orderId: state.orderId,
      currentStep: state.currentStep,
      data: state.data
    };
    
    // 3. Handle concurrent updates
    // ⚠️ Need optimistic locking (version checking)
    const lock = await this.redis.acquireLock(`workflow:${state.workflowId}`, 30000);
    if (!lock) {
      throw new Error("Failed to acquire lock");
    }
    
    try {
      // 4. Continue execution
      if (state.currentStep === "waiting_for_approval") {
        if (decision === "APPROVED") {
          await this.processOrder(context);
        } else {
          await this.rejectOrder(context);
        }
      }
      
      // 5. Update state
      await this.db.updateWorkflowState(state.workflowId, {
        currentStep: "completed",
        status: "SUCCESS",
        completedAt: Date.now()
      });
      
    } finally {
      await this.redis.releaseLock(lock);
    }
    
    // Total for webhook handler: ~200 lines
  }
}
 
// Total infrastructure code: ~1,190 lines
// And this doesn't even handle:
// - Process crashes during execution
// - Deployment rollouts (loses in-memory state)
// - Database connection failures
// - Redis unavailability
// - Kafka rebalancing

workflows:
  - name: process-order
    start: WaitForApproval
    
    states:
      - name: WaitForApproval
        type: Task
        resource: "urn:cascade:waitFor:human"
        parameters:
          schema:
            type: object
            properties:
              decision: {type: string, enum: ["APPROVED", "REJECTED"]}
              notes: {type: string}
          assignment:
            role: "Manager"
            # Automatically routes to managers in tenant
          timeout: "7d"  # ← Workflow pauses for 7 DAYS!
        result_path: "$.approval"
        next: CheckDecision
      
      - name: CheckDecision
        type: Choice
        choices:
          - variable: "$.approval.decision"
            string_equals: "APPROVED"
            next: ProcessPayment
        default: NotifyRejection
      
      - name: ProcessPayment
        type: Task
        resource: "urn:cascade:action:process-payment"
        next: Complete

async function callPaymentAPI(payload) {
  let attempt = 0;
  const maxAttempts = 3;
  let delay = 1000;
  
  while (attempt < maxAttempts) {
    try {
      return await stripe.charge(payload);
    } catch (error) {
      attempt++;
      
      // Classify error manually
      const isTransient = 
        error.code === "NetworkError" ||
        error.code === "ServiceUnavailable";
      
      if (!isTransient || attempt >= maxAttempts) {
        throw error;
      }
      
      // Exponential backoff with jitter
      await sleep(delay);
      delay = Math.min(delay * 2, 10000);
      delay = delay * (1 + Math.random() * 0.2);
    }
  }
}

- name: ChargePayment
  type: Task
  resource: "urn:cascade:action:stripe.charge"
  parameters:
    amount.$: "$.order.total"
    customer.$: "$.customer.id"
  
  retry:
    - error_equals: ["NetworkError", "ServiceUnavailable", "TimeoutError"]
      max_attempts: 3
      interval_seconds: 1
      backoff_rate: 2.0
      max_interval_seconds: 10
      jitter_strategy: "FULL"
  
  catch:
    - error_equals: ["CardDeclined", "ValidationError"]
      result_path: "$.payment_error"
      next: NotifyPaymentFailed
  
  result_path: "$.payment"
  next: ReserveInventory

// Traditional Node.js with PostgreSQL
class InventoryService {
  constructor() {
    // Manual connection pool setup (~300 lines)
    this.pool = new PgPool({
      host: process.env.DB_HOST,
      database: process.env.DB_NAME,
      max: 20,
      idleTimeoutMillis: 30000,
      connectionTimeoutMillis: 2000,
    });
  }
  
  async checkStock(productIds, warehouseId, tenantId) {
    // ⚠️ SECURITY RISK: Easy to forget tenant_id
    const query = `
      SELECT 
        product_id, 
        available_quantity,
        reserved_quantity
      FROM inventory
      WHERE product_id = ANY($1)
        AND warehouse_id = $2
        AND tenant_id = $3  -- ← MUST NEVER FORGET THIS!
    `;
    
    let client;
    try {
      // Manual connection management
      client = await this.pool.connect();
      
      const result = await client.query(query, [
        productIds,
        warehouseId,
        tenantId  // ← Must pass everywhere, error-prone
      ]);
      
      return result.rows;
      
    } catch (error) {
      // Manual error handling, retry logic, logging...
      if (error.code === 'CONNECTION_LOST') {
        await sleep(1000);
        return this.checkStock(productIds, warehouseId, tenantId);
      }
      
      if (error.code === 'DEADLOCK') {
        throw new RetryableError("Database deadlock");
      }
      
      // Log error manually
      logger.error('Query failed', { error, query, params });
      throw error;
      
    } finally {
      // Manual connection cleanup
      if (client) client.release();
    }
  }
  
  async reserveInventory(productId, quantity, warehouseId, tenantId) {
    // Another 80+ lines for transaction management...
    const client = await this.pool.connect();
    try {
      await client.query('BEGIN');
      
      // Lock row
      await client.query(`
        SELECT available_quantity 
        FROM inventory 
        WHERE product_id = $1 AND warehouse_id = $2 AND tenant_id = $3
        FOR UPDATE
      `, [productId, warehouseId, tenantId]);
      
      // Update quantity
      await client.query(`
        UPDATE inventory 
        SET reserved_quantity = reserved_quantity + $1
        WHERE product_id = $2 AND warehouse_id = $3 AND tenant_id = $4
      `, [quantity, productId, warehouseId, tenantId]);
      
      await client.query('COMMIT');
    } catch (error) {
      await client.query('ROLLBACK');
      throw error;
    } finally {
      client.release();
    }
  }
}
 
// Every service needs:
// - Connection pooling (~300 lines)
// - Error classification (~200 lines)
// - Retry logic (~150 lines)
// - Logging integration (~100 lines)
// - Transaction management (~200 lines)
// - Deadlock recovery (~80 lines)
// = 1,030+ lines BEFORE business logic

# service.yaml - Define queries declaratively
spec:
  components:
    queries:
      # Read-only query (type-safe)
      - name: check-inventory
        type: sql
        operation: select
        source: |
          SELECT 
            product_id,
            available_quantity,
            reserved_quantity
          FROM inventory
          WHERE product_id = ANY(:productIds)
            AND warehouse_id = :warehouseId
            -- tenant_id is AUTOMATIC (platform injects)
        
        parameters:
          productIds: 
            type: array
            items: { type: uuid }
            required: true
          warehouseId: 
            type: uuid
            required: true
        
        returns:
          type: array
          items:
            type: object
            properties:
              product_id: { type: uuid }
              available_quantity: { type: integer }
              reserved_quantity: { type: integer }

workflows:
  - name: process-order
    states:
      - name: CheckInventory
        type: Task
        resource: "urn:cascade:query:check-inventory"
        parameters:
          productIds.$: "$.order.items[*].product_id"
          warehouseId.$: "$.order.warehouse_id"
        result_path: "$.inventory"
        next: ValidateStock
      
      - name: ValidateStock
        type: Choice
        choices:
          - variable: "$.inventory[?(@.available_quantity < @.reserved_quantity)]"
            is_present: true
            next: OutOfStock
        default: ReserveInventory

# Workflow calls custom action
- name: CheckInventory
  type: Task
  resource: "urn:cascade:action:check-inventory-with-logic"
  parameters:
    product_ids.$: "$.order.items[*].product_id"
    warehouse.$: "$.order.warehouse"
  result_path: "$.inventory"
  next: ValidateStock

package actions
 
import (
    "context"
    cascade "github.com/cascade-platform/sdk-go"
)
 
func CheckInventoryWithLogic(ctx context.Context, input Input) (*Output, error) {
    sdk := cascade.FromContext(ctx)
    
    // ✅ Tenant isolation is AUTOMATIC
    rows, err := sdk.DatabaseQuery(ctx, `
        SELECT 
            product_id, 
            available_quantity,
            reserved_quantity,
            warehouse_id
        FROM inventory
        WHERE product_id = ANY($1) 
          AND warehouse_id = $2
          -- tenant_id is AUTOMATIC (platform injects)
    `, map[string]interface{}{
        "product_ids": input.ProductIDs,
        "warehouse":   input.Warehouse,
        // NO need to pass tenant_id - SDK adds it automatically
    })
    
    if err != nil {
        return nil, err // Platform handles retry/logging
    }
    
    // Custom business logic
    available := make([]Item, 0)
    for _, row := range rows {
        if row["available_quantity"].(int) > row["reserved_quantity"].(int) {
            available = append(available, Item{
                ProductID:  row["product_id"].(string),
                Available:  row["available_quantity"].(int),
                Reserved:   row["reserved_quantity"].(int),
            })
        }
    }
    
    return &Output{
        Items:     available,
        AllAvailable: len(available) == len(input.ProductIDs),
    }, nil
}

# Workflow uses WASM action
- name: CheckInventory
  type: Task
  resource: "urn:cascade:action:check-inventory-wasm"
  runtime: wasm  # ← Compiled to WebAssembly
  parameters:
    product_ids.$: "$.order.items[*].product_id"
    warehouse.$: "$.order.warehouse"
  result_path: "$.inventory"

// actions/check_inventory.rs
use cascade_wasm_sdk::*;
 
#[cascade_action]
pub fn check_inventory(input: Input) -> Result<Output, Error> {
    // Access platform capabilities via WASM host functions
    let rows = database_query(
        "SELECT product_id, available_quantity, reserved_quantity 
         FROM inventory 
         WHERE product_id = ANY($1) AND warehouse_id = $2",
        &[&input.product_ids, &input.warehouse]
    )?;
    
    // Custom logic (runs in WASM sandbox)
    let available: Vec<Item> = rows.iter()
        .filter(|r| r.available > r.reserved)
        .map(|r| Item {
            product_id: r.product_id.clone(),
            available: r.available,
            reserved: r.reserved,
        })
        .collect();
    
    Ok(Output {
        items: available,
        all_available: available.len() == input.product_ids.len(),
    })
}

# Compile Rust to WASM
cargo build --target wasm32-wasi --release
 
# Platform automatically loads and executes
# Cold start: <1ms
# Hot path: <0.1ms

- name: RouteByAmount
  type: Choice
  choices:
    - variable: "$.expense.amount"
      numeric_less_than: 500
      next: AutoApprove
    
    - variable: "$.expense.amount"
      numeric_less_than: 5000
      next: ManagerApproval
    
    - variable: "$.expense.amount"
      numeric_less_than: 20000
      next: DirectorApproval
  
  default: CFOApproval

package cascade.expense

default approver = "manager"
default requires_approval = true

# Executive privilege
approver = "auto" {
    input.employee.level == "executive"
}

# Amount-based routing
approver = "auto" { input.amount < 500 }
approver = "manager" { input.amount >= 500; input.amount < 5000 }
approver = "director" { input.amount >= 5000; input.amount < 20000 }
approver = "cfo" { input.amount >= 20000 }

# Category overrides
approver = "cfo" {
    input.category == "travel"
    input.amount > 10000
}

- name: EvaluateExpenseRules
  type: Task
  resource: "urn:cascade:dmn:expense-routing-rules"
  parameters:
    expense_amount.$: "$.expense.amount"
    employee_level.$: "$.employee.level"
    category.$: "$.expense.category"
  result_path: "$.routing_decision"

- name: PublishOrderCreated
  type: Task
  resource: "urn:cascade:event:publish"
  parameters:
    type: "com.acme.order.created"
    source: "urn:cascade:workflow:order-processing"
    data:
      order_id.$: "$.order.id"
      customer_id.$: "$.order.customer_id"
      total.$: "$.order.total"
  next: Complete

apiVersion: cascade.io/v1
kind: EventRouter
metadata:
  name: order-events
 
spec:
  routing_rules:
    - name: route-high-value
      pattern: "com.acme.order.created"
      filters:
        - "$.data.total > 1000"
      actions:
        - start_process: "fraud-detection"
          parameters:
            order_id: "$.data.order_id"
    
    - name: route-inventory
      pattern: "com.acme.order.*"
      actions:
        - signal_process: "inventory-management"
          signal_name: "order_placed"

- name: InitiatePayment
  type: Task
  resource: "urn:cascade:action:stripe.charge"
  parameters:
    amount.$: "$.order.total"
  result_path: "$.payment"
  next: WaitForCallback
 
- name: WaitForCallback
  type: Task
  resource: "urn:cascade:waitFor:webhook"
  parameters:
    schema:
      type: object
      properties:
        transaction_id: {type: string}
        status: {type: string, enum: ["success", "failure"]}
    timeout: "30m"
  result_path: "$.callback"
  catch:
    - error_equals: ["TimeoutError"]
      next: RetryPayment
  next: CheckStatus
 
- name: CheckStatus
  type: Choice
  choices:
    - variable: "$.callback.status"
      string_equals: "success"
      next: ReserveInventory
  default: RefundPayment

-- Migration 001_create_customers.sql (100 lines)
CREATE TABLE app.customers (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL UNIQUE,
    ...
);
 
-- Migration 002_create_orders.sql (80 lines)
-- Migration 003_add_status_column.sql (50 lines)
-- ... 47 more migrations for a 50-table system

schema "app" {}
 
table "customers" {
  schema = schema.app
  column "id" {
    type    = "uuid"
    default = sql("gen_random_uuid()")
  }
  column "email" {
    type = "varchar(255)"
    null = false
  }
  column "status" {
    type    = "varchar(50)"
    default = "active"
  }
  
  primary_key {
    columns = [column.id]
  }
  unique "unique_email" {
    columns = [column.email]
  }
}
 
table "orders" {
  schema = schema.app
  column "id" {
    type    = "uuid"
    default = sql("gen_random_uuid()")
  }
  column "customer_id" {
    type = "uuid"
    null = false
  }
  
  foreign_key "fk_customer" {
    columns     = [column.customer_id]
    ref_columns = [table.customers.column.id]
    on_delete   = "RESTRICT"
  }
}

# resources/orders.dspec.yaml
spec:
  resources:
    - name: Order
      description: Customer order
      type: aggregate
      entity: orders
      
      fields:
        - name: id
          type: uuid
          description: Order ID
        - name: customer_id
          type: uuid
          required: true
        - name: status
          type: string
          enum: ["PENDING", "PROCESSING", "COMPLETED", "CANCELLED"]
          default: "PENDING"
        - name: total
          type: decimal
          minimum: 0
        - name: created_at
          type: timestamp
          readonly: true
      
      # Auto-generate CRUD endpoints
      endpoints:
        create: true
        read: true
        update: true
        delete: true
      
      # Auto-generate search/filtering
      search:
        - field: status
          type: exact
        - field: customer_id
          type: exact
        - field: created_at
          type: range
        - field: total
          type: range
      
      # Auto-generate pagination
      pagination:
        default_limit: 50
        max_limit: 500

GET    /orders                      # List with search & pagination
POST   /orders                      # Create
GET    /orders/{id}                 # Read
PUT    /orders/{id}                 # Update
DELETE /orders/{id}                 # Delete

# resources/orders.dspec.yaml
spec:
  resources:
    - name: Order
      entity: orders
      
      endpoints:
        create: 
          enabled: true
          refine: "urn:cascade:action:validate-order-creation"  # ← Custom logic
        
        read: true  # Standard CRUD
        
        update:
          enabled: true
          refine: "urn:cascade:action:validate-order-update"
          allowed_fields: ["status", "notes"]  # Only these can be updated
        
        delete:
          enabled: false  # Not allowed
      
      # Custom endpoints beyond CRUD
      custom_endpoints:
        - name: "cancel-order"
          method: POST
          path: "/orders/{id}/cancel"
          action: "urn:cascade:action:cancel-order"
          description: "Cancel an order (only if status is PENDING or PROCESSING)"
        
        - name: "ship-order"
          method: POST
          path: "/orders/{id}/ship"
          action: "urn:cascade:action:ship-order"
          description: "Mark order as shipped"

package actions
 
func ValidateOrderCreation(ctx context.Context, order Order) (*Order, error) {
    sdk := cascade.FromContext(ctx)
    
    // Custom validation: check inventory
    inventory, err := sdk.DatabaseQuery(ctx, `
        SELECT available_quantity FROM inventory 
        WHERE product_id = ANY($1)
    `, map[string]interface{}{"product_ids": order.Items})
    
    if err != nil {
        return nil, err
    }
    
    // Custom logic: verify sufficient inventory
    for _, item := range order.Items {
        if item.Quantity > inventory[item.ProductID] {
            return nil, &ValidationError{
                Field: "items",
                Message: "Insufficient inventory",
            }
        }
    }
    
    return &order, nil
}

# REST API: Domain-driven endpoints only
spec:
  api_endpoints:
    - name: GetAssignedTasks
      method: GET
      path: /tasks
      description: List tasks assigned to current user
      
    - name: CompleteUserTask
      method: POST
      path: /tasks/{id}/complete
      description: Submit human task completion
      parameters:
        - name: id
          type: uuid
          required: true
        - name: body
          type: object
          schema:
            type: object
            properties:
              decision: {type: string}
              notes: {type: string}
    
    - name: QueryProcessInstance
      method: GET
      path: /processes/{id}
      description: Get process execution state and history

anonymous:
  limit: 100 requests / 15 min
  burst: 20
 
authenticated_user:
  limit: 1,000 requests / 15 min
  burst: 100
 
service_account:
  limit: 50,000 requests / 15 min
  burst: 2,000