Snowflake Architecture Variants

Overview

Three validated architecture blueprints for Snowflake integrations.

Prerequisites

• Understanding of team size and DAU requirements
• Knowledge of deployment infrastructure
• Clear SLA requirements
• Growth projections available

Variant A: Monolith (Simple)

Best for: MVPs, small teams, < 10K daily active users

my-app/
├── src/
│   ├── snowflake/
│   │   ├── client.ts          # Singleton client
│   │   ├── types.ts           # Types
│   │   └── middleware.ts      # Express middleware
│   ├── routes/
│   │   └── api/
│   │       └── snowflake.ts    # API routes
│   └── index.ts
├── tests/
│   └── snowflake.test.ts
└── package.json

Key Characteristics

• Single deployment unit
• Synchronous Snowflake calls in request path
• In-memory caching
• Simple error handling

Code Pattern

// Direct integration in route handler
app.post('/api/create', async (req, res) => {
  try {
    const result = await snowflakeClient.create(req.body);
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Variant B: Service Layer (Moderate)

Best for: Growing startups, 10K-100K DAU, multiple integrations

my-app/
├── src/
│   ├── services/
│   │   ├── snowflake/
│   │   │   ├── client.ts      # Client wrapper
│   │   │   ├── service.ts     # Business logic
│   │   │   ├── repository.ts  # Data access
│   │   │   └── types.ts
│   │   └── index.ts           # Service exports
│   ├── controllers/
│   │   └── snowflake.ts
│   ├── routes/
│   ├── middleware/
│   ├── queue/
│   │   └── snowflake-processor.ts  # Async processing
│   └── index.ts
├── config/
│   └── snowflake/
└── package.json

Key Characteristics

• Separation of concerns
• Background job processing
• Redis caching
• Circuit breaker pattern
• Structured error handling

Code Pattern

// Service layer abstraction
class SnowflakeService {
  constructor(
    private client: SnowflakeClient,
    private cache: CacheService,
    private queue: QueueService
  ) {}

  async createResource(data: CreateInput): Promise<Resource> {
    // Business logic before API call
    const validated = this.validate(data);

    // Check cache
    const cached = await this.cache.get(cacheKey);
    if (cached) return cached;

    // API call with retry
    const result = await this.withRetry(() =>
      this.client.create(validated)
    );

    // Cache result
    await this.cache.set(cacheKey, result, 300);

    // Async follow-up
    await this.queue.enqueue('snowflake.post-create', result);

    return result;
  }
}

Snowflake CI Integration

Overview

Set up CI/CD pipelines for Snowflake integrations with automated testing.

Prerequisites

• GitHub repository with Actions enabled
• Snowflake test API key
• npm/pnpm project configured

Instructions

Step 1: Create GitHub Actions Workflow

Create .github/workflows/snowflake-integration.yml:

name: Snowflake Integration Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

env:
  SNOWFLAKE_API_KEY: ${{ secrets.SNOWFLAKE_API_KEY }}

jobs:
  test:
    runs-on: ubuntu-latest
    env:
      SNOWFLAKE_API_KEY: ${{ secrets.SNOWFLAKE_API_KEY }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      - run: npm ci
      - run: npm test -- --coverage
      - run: npm run test:integration

Step 2: Configure Secrets

gh secret set SNOWFLAKE_API_KEY --body "sk_test_***"

Step 3: Add Integration Tests

describe('Snowflake Integration', () => {
  it.skipIf(!process.env.SNOWFLAKE_API_KEY)('should connect', async () => {
    const client = getSnowflakeClient();
    const result = await client.healthCheck();
    expect(result.status).toBe('ok');
  });
});

Output

• Automated test pipeline
• PR checks configured
• Coverage reports uploaded
• Release workflow ready

Error Handling

Examples

Release Workflow

on:
  push:
    tags: ['v*']

jobs:
  release:
    runs-on: ubuntu-latest
    env:
      SNOWFLAKE_API_KEY: ${{ secrets.SNOWFLAKE_API_KEY_PROD }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - name: Verify Snowflake production readiness
        run: npm run test:integration
      - run: npm run build
      - run: npm publish

Branch Protection

required_status_checks:
  - "test"
  - "snowflake-integration"

Resources

• GitHub Actions Documentation
• Snowflake CI Guide

Next Steps

For dep

Snowflake Common Errors

Overview

Quick reference for the top 10 most common Snowflake errors and their solutions.

Prerequisites

• Snowflake SDK installed
• API credentials configured
• Access to error logs

Instructions

Step 1: Identify the Error

Check error message and code in your logs or console.

Step 2: Find Matching Error Below

Match your error to one of the documented cases.

Step 3: Apply Solution

Follow the solution steps for your specific error.

Output

• Identified error cause
• Applied fix
• Verified resolution

Error Handling

Authentication Failed

Error Message:

Authentication error: Invalid API key

Cause: API key is missing, expired, or invalid.

Solution:

# Verify API key is set
echo $SNOWFLAKE_API_KEY

Rate Limit Exceeded

Error Message:

Rate limit exceeded. Please retry after X seconds.

Cause: Too many requests in a short period.

Solution:

Implement exponential backoff. See snowflake-rate-limits skill.

Network Timeout

Error Message:

Request timeout after 30000ms

Cause: Network connectivity or server latency issues.

Solution:

// Increase timeout
const client = new Client({ timeout: 60000 });

Examples

Quick Diagnostic Commands

# Check Snowflake status
curl -s https://status.snowflake.com

# Verify API connectivity
curl -I https://api.snowflake.com

# Check local configuration
env | grep SNOWFLAKE

Escalation Path

1. Collect evidence with snowflake-debug-bundle
2. Check Snowflake status page
3. Contact support with request ID

Resources

• Snowflake Status Page
• Snowflake Support
• Snowflake Error Codes

Next Steps

For comprehensive debugging, see snowflake-debug-bundle.

Snowflake Core Workflow A

Overview

Primary money-path workflow for Snowflake. This is the most common use case.

Prerequisites

• Completed snowflake-install-auth setup
• Understanding of Snowflake core concepts
• Valid API credentials configured

Instructions

Step 1: Initialize

// Step 1 implementation

Step 2: Execute

// Step 2 implementation

Step 3: Finalize

// Step 3 implementation

Output

• Completed Core Workflow A execution
• Expected results from Snowflake API
• Success confirmation or error details

Error Handling

Examples

Complete Workflow

// Complete workflow example

Common Variations

• Variation 1: Description
• Variation 2: Description

Resources

• Snowflake Documentation
• Snowflake API Reference

Next Steps

For secondary workflow, see snowflake-core-workflow-b.

Snowflake Core Workflow B

Overview

Secondary workflow for Snowflake. Complements the primary workflow.

Prerequisites

• Completed snowflake-install-auth setup
• Familiarity with snowflake-core-workflow-a
• Valid API credentials configured

Instructions

Step 1: Setup

// Step 1 implementation

Step 2: Process

// Step 2 implementation

Step 3: Complete

// Step 3 implementation

Output

• Completed Core Workflow B execution
• Results from Snowflake API
• Success confirmation or error details

Error Handling

Examples

Complete Workflow

// Complete workflow example

Error Recovery

// Error handling code

Resources

• Snowflake Documentation
• Snowflake API Reference

Next Steps

For common errors, see snowflake-common-errors.

Snowflake Cost Tuning

Overview

Optimize Snowflake costs through smart tier selection, sampling, and usage monitoring.

Prerequisites

• Access to Snowflake billing dashboard
• Understanding of current usage patterns
• Database for usage tracking (optional)
• Alerting system configured (optional)

Pricing Tiers

Cost Estimation

interface UsageEstimate {
  requestsPerMonth: number;
  tier: string;
  estimatedCost: number;
  recommendation?: string;
}

function estimateSnowflakeCost(requestsPerMonth: number): UsageEstimate {
  if (requestsPerMonth <= 1000) {
    return { requestsPerMonth, tier: 'Free', estimatedCost: 0 };
  }

  if (requestsPerMonth <= 100000) {
    return { requestsPerMonth, tier: 'Pro', estimatedCost: 99 };
  }

  const proOverage = (requestsPerMonth - 100000) * 0.001;
  const proCost = 99 + proOverage;

  return {
    requestsPerMonth,
    tier: 'Pro (with overage)',
    estimatedCost: proCost,
    recommendation: proCost > 500
      ? 'Consider Enterprise tier for volume discounts'
      : undefined,
  };
}

Usage Monitoring

class SnowflakeUsageMonitor {
  private requestCount = 0;
  private bytesTransferred = 0;
  private alertThreshold: number;

  constructor(monthlyBudget: number) {
    this.alertThreshold = monthlyBudget * 0.8; // 80% warning
  }

  track(request: { bytes: number }) {
    this.requestCount++;
    this.bytesTransferred += request.bytes;

    if (this.estimatedCost() > this.alertThreshold) {
      this.sendAlert('Approaching Snowflake budget limit');
    }
  }

  estimatedCost(): number {
    return estimateSnowflakeCost(this.requestCount).estimatedCost;
  }

  private sendAlert(message: string) {
    // Send to Slack, email, PagerDuty, etc.
  }
}

Cost Reduction Strategies

Step 1: Request Sampling

function shouldSample(samplingRate = 0.1): boolean {
  return Math.random() < samplingRate;
}

// Use for non-critical telemetry
if (shouldSample(0.1)) { // 10% sample
  await snowflakeClient.trackEvent(event);
}

Step 2: Batching Requests

// Instead of N individual calls
await Promise.all(ids.map(id => snowflakeClient.get(id)));

// Use batch endpoint (1 call)
await snowflakeClient.batchGet(ids);

Step 3: Caching (from P16)

• Cache frequently accessed data