Core Technologies

┌─────────────┐     ┌──────────────┐     ┌──────────────┐
│   Console   │────▶│Credit Engine │────▶│ TigerBeetle  │
│  (Frontend) │     │   (Backend)  │     │   (Ledger)   │
└─────────────┘     └──────────────┘     └──────────────┘
                            │                     │
                            ▼                     │
                    ┌──────────────┐             │
                    │   Supabase   │◀────────────┘
                    │  (Metadata)  │   (Analytics)
                    └──────────────┘

interface TigerBeetleAccount {
  id: bigint              // 128-bit unique identifier
  ledger: number          // Ledger ID for multi-ledger support
  code: number            // Account type code
  flags: AccountFlags     // Account behavior flags
  debits_pending: bigint  // Pending debit amount
  debits_posted: bigint   // Posted debit amount
  credits_pending: bigint // Pending credit amount
  credits_posted: bigint  // Posted credit amount
}

interface Transfer {
  id: bigint              // Unique transfer ID
  debit_account_id: bigint
  credit_account_id: bigint
  amount: bigint          // Amount in smallest currency unit
  pending_id: bigint      // For two-phase commits
  timeout: number         // Timeout for pending transfers
  ledger: number
  code: number            // Transfer type code
  flags: TransferFlags
  timestamp: bigint       // Nanosecond precision
}

GKE Cluster Configuration:
  - Platform: Google Kubernetes Engine (GKE) Standard
  - Region: us-central1
  - Nodes: 3 × c3-standard-4-lssd (dedicated pool)
  - Storage: 375GB local NVMe SSD per node
  - Memory: 15GB RAM per node
  - CPU: 4 vCPUs per node
  - Network: External LoadBalancer (104.154.31.249:3003)
 
Monitoring Stack:
  - Metrics: Prometheus + StatsD Exporter
  - Dashboards: Grafana (http://34.172.102.114)
  - Alerts: Configured for replica health, latency, storage
 
Performance Achieved:
  - Throughput: 10,000+ TPS verified
  - Latency: Sub-millisecond p99
  - Availability: 99.99% uptime target
  - Recovery: Automated with StatefulSet

// Plaid Service Architecture
class PlaidService {
  // Link Token for Plaid Link
  async createLinkToken(userId: string): Promise<LinkToken> {
    return await plaidClient.linkTokenCreate({
      user: { client_user_id: userId },
      products: ['transactions', 'accounts', 'investments'],
      country_codes: ['US', 'CA'],
      language: 'en'
    })
  }
 
  // Exchange public token for access token
  async exchangeToken(publicToken: string): Promise<string> {
    const response = await plaidClient.itemPublicTokenExchange({
      public_token: publicToken
    })
    return response.data.access_token
  }
 
  // Sync transactions incrementally
  async syncTransactions(accessToken: string): Promise<Transaction[]> {
    const response = await plaidClient.transactionsSync({
      access_token: accessToken
    })
    return this.processTransactions(response.data)
  }
}

Rate Limits:
  - Transactions: 1 request/second per item
  - Accounts: 5 requests/second per item
  - Auth: 1 request/second per item
  - Identity: 1 request/second per item
 
Best Practices:
  - Use webhooks for real-time updates
  - Implement exponential backoff
  - Cache account data appropriately
  - Handle ITEM_LOGIN_REQUIRED errors
  - Implement update scheduling

-- Users table (managed by Supabase Auth)
CREATE TABLE profiles (
  id UUID REFERENCES auth.users PRIMARY KEY,
  email TEXT UNIQUE NOT NULL,
  full_name TEXT,
  avatar_url TEXT,
  created_at TIMESTAMPTZ DEFAULT NOW(),
  updated_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- Financial institutions
CREATE TABLE institutions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  plaid_institution_id TEXT UNIQUE,
  name TEXT NOT NULL,
  logo_url TEXT,
  primary_color TEXT,
  url TEXT
);
 
-- User accounts
CREATE TABLE accounts (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id UUID REFERENCES profiles(id),
  institution_id UUID REFERENCES institutions(id),
  plaid_account_id TEXT UNIQUE,
  tigerbeetle_account_id BIGINT UNIQUE,
  account_name TEXT,
  account_type TEXT,
  account_subtype TEXT,
  created_at TIMESTAMPTZ DEFAULT NOW()
);
 
-- Enable Row Level Security
ALTER TABLE accounts ENABLE ROW LEVEL SECURITY;
 
-- RLS Policies
CREATE POLICY "Users can view own accounts" ON accounts
  FOR SELECT USING (auth.uid() = user_id);
 
CREATE POLICY "Users can insert own accounts" ON accounts
  FOR INSERT WITH CHECK (auth.uid() = user_id);

// Real-time balance updates
const balanceSubscription = supabase
  .channel('balance-changes')
  .on('postgres_changes',
    {
      event: 'UPDATE',
      schema: 'public',
      table: 'accounts',
      filter: `user_id=eq.${userId}`
    },
    (payload) => {
      updateUIBalance(payload.new)
    }
  )
  .subscribe()
 
// Presence for collaboration
const roomOne = supabase.channel('room_one')
roomOne
  .on('presence', { event: 'sync' }, () => {
    const state = roomOne.presenceState()
    console.log('Online users:', state)
  })
  .subscribe()

// File upload for documents
const { data, error } = await supabase
  .storage
  .from('documents')
  .upload(`tax-docs/${year}/${filename}`, file, {
    cacheControl: '3600',
    upsert: false
  })
 
// Secure file access
const { data: signedUrl } = await supabase
  .storage
  .from('documents')
  .createSignedUrl(path, 3600)

// Edge function for AI processing
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts'
 
serve(async (req) => {
  const { transaction } = await req.json()
 
  // Call AI service
  const category = await categorizeTransaction(transaction)
 
  // Store in database
  const { data, error } = await supabase
    .from('transaction_categories')
    .insert({
      transaction_id: transaction.id,
      category,
      confidence: category.confidence
    })
 
  return new Response(JSON.stringify({ category }))
})

Infrastructure:
  - Database: Dedicated instance with 8 vCPUs, 32GB RAM
  - Connection Pooling: PgBouncer with 100 connections
  - Read Replicas: 2 replicas for read scaling
  - CDN: Global edge network for assets
 
Limits:
  - API: 1000 requests/minute
  - Database: 100 concurrent connections
  - Storage: 100GB included
  - Bandwidth: 250GB/month

// Hyperswitch Integration
class PaymentService {
  async createPayment(params: PaymentRequest): Promise<Payment> {
    const payment = await hyperswitch.payments.create({
      amount: params.amount,
      currency: params.currency,
      customer_id: params.customerId,
      routing: {
        type: 'priority',
        data: [
          {
            processor: 'stripe',
            priority: 1,
            conditions: { amount: { max: 10000 } }
          },
          {
            processor: 'adyen',
            priority: 2,
            conditions: { amount: { min: 10000 } }
          }
        ]
      },
      capture_method: 'automatic',
      authentication_type: 'three_ds',
      metadata: params.metadata
    })
 
    return this.recordInLedger(payment)
  }
 
  async recordInLedger(payment: Payment): Promise<Payment> {
    // Record in TigerBeetle
    await tigerbeetle.createTransfer({
      id: BigInt(payment.id),
      debit_account_id: payment.source_account,
      credit_account_id: payment.destination_account,
      amount: BigInt(payment.amount),
      code: TransferCode.PAYMENT,
      flags: TransferFlags.NONE
    })
 
    return payment
  }
}

Routing Rules:
  # Cost-optimized routing
  - name: minimize_cost
    conditions:
      - payment_method: card
      - amount: { min: 10, max: 1000 }
    actions:
      - route_to:
          processors: [stripe, square]
          algorithm: lowest_fee
 
  # High-value routing
  - name: high_value_payments
    conditions:
      - amount: { min: 10000 }
    actions:
      - route_to:
          processors: [adyen, checkout]
          algorithm: highest_success_rate
      - enable_3ds: required
      - fraud_check: enhanced
 
  # Regional routing
  - name: eu_payments
    conditions:
      - customer_country: [DE, FR, ES, IT]
      - currency: EUR
    actions:
      - route_to:
          processors: [adyen, mollie]
          algorithm: lowest_latency

// Recurring payment setup
const subscription = await hyperswitch.subscriptions.create({
  customer_id: customerId,
  plan: {
    amount: 9999, // $99.99
    currency: 'USD',
    interval: 'month',
    interval_count: 1
  },
  payment_method: paymentMethodId,
  metadata: {
    product: 'premium_plan',
    user_id: userId
  }
})
 
// Automatic retry logic
const retryConfig = {
  max_attempts: 3,
  retry_interval: 86400, // 1 day
  dunning_emails: true,
  final_action: 'cancel'
}

Metrics Tracked:
  - Payment success rate by processor
  - Average processing time
  - Cost per transaction
  - Decline reasons
  - Fraud detection rate
  - 3DS challenge rate
  - Chargeback rate
 
Monitoring:
  - Real-time dashboard
  - Webhook notifications
  - Prometheus metrics
  - Custom alerts
  - Anomaly detection