Imported from jeremylongshore/tons-of-skills-marketplace (plugins/saas-packs/finta-pack/skills/finta-performance-tuning/SKILL.md). Install upstream with npx skills add jeremylongshore/tons-of-skills-marketplace --skill finta-performance-tuning. Copyright stays with the author (MIT).

Finta Performance Tuning

Overview

Finta's fundraising API handles investor list pagination, round data aggregation, and CRM sync batching. Founders querying large investor databases (1,000+ contacts) hit pagination bottlenecks, while round aggregation across multiple funding stages compounds latency. Optimizing paginated fetches with cursor-based iteration, caching investor profiles, and batching CRM sync writes reduces pipeline load times by 50-70% and keeps fundraising dashboards responsive during active rounds.

Prerequisites

• A baseline from aggregate, redacted latency and error metrics; do not copy investor records into performance traces.
• An approved capacity target and freshness expectation for each dashboard or sync.
• A staging environment with synthetic data and a rollback switch for cache, queue, and concurrency changes.

Instructions

1. Measure one bottleneck at a time: pagination, cache misses, queue depth, or destination latency.
2. Set bounded concurrency and exponential backoff before increasing throughput; respect provider responses rather than assuming a rate limit.
3. Cache only data that is permitted to persist and define invalidation on the write path; do not trade data isolation for a higher hit rate.
4. Roll out a small canary, compare redacted metrics against the baseline, and revert if error rate, staleness, or queue age breaches the agreed threshold.
5. Record the observed result and owner so the tuning change can be reviewed or removed later.

Caching Strategy

const cache = new Map<string, { data: any; expiry: number }>();
const TTL = { investors: 600_000, rounds: 300_000, pipeline: 120_000 };

async function cached(key: string, ttlKey: keyof typeof TTL, fn: () => Promise<any>) {
  const entry = cache.get(key);
  if (entry && entry.expiry > Date.now()) return entry.data;
  const data = await fn();
  cache.set(key, { data, expiry: Date.now() + TTL[ttlKey] });
  return data;
}
// Investor profiles change rarely (10 min). Pipeline stages are volatile (2 min).

Batch Operations

async function syncInvestorsBatch(client: any, cursor?: string, pageSize = 100) {
  const allInvestors = [];
  let nextCursor = cursor;
  do {
    const page = await client.listInvestors({ cursor: nextCursor, limit: pageSize });
    allInvestors.push(...page.data);
    nextCursor = page.next_cursor;
    if (nextCursor) await new Promise(r => setTimeout(r, 200));
  } while (nextCursor);
  return allInvestors;
}

Connection Pooling

import { Agent } from 'https';
const agent = new Agent({ keepAlive: true, maxSockets: 8, maxFreeSockets: 4, timeout: 30_000 });
// Finta API calls are lightweight — moderate socket count suffices

Rate Limit Management

async function withRateLimit(fn: () => Promise<any>): Promise<any> {
  const res = await fn();
  const remaining = parseInt(res.headers?.['x-ratelimit-remaining'] || '50');
  if (remaining < 3) {
    const resetMs = parseInt(res.headers?.['x-ratelimit-reset'] || '5') * 1000;
    await new Promise(r => setTimeout(r, resetMs));
  }
  return res;
}

Monitoring

const metrics = { apiCalls: 0, cacheHits: 0, syncErrors: 0, avgLatencyMs: 0 };
function track(startMs: number, cached: boolean, error?: boolean) {
  metrics.apiCalls++;
  metrics.avgLatencyMs = (metrics.avgLatencyMs * (metrics.apiCalls - 1) + (Date.now() - startMs)) / metrics.apiCalls;
  if (cached) metrics.cacheHits++; if (error) metrics.syncErrors++;
}

Performance Checklist

• Use cursor-based pagination for investor lists (not offset)
• Cache investor profiles with 10-min TTL
• Batch CRM sync writes in groups of 50
• Aggregate round data client-side to avoid repeated queries
• Enable HTTP keep-alive for persistent connections
• Parse rate limit headers and pause before exhaustion
• Prefetch deal room analytics during idle periods
• Set pipeline cache TTL to 2 min for active-round freshness

Error Handling

Output

Publish a performance receipt with the baseline and post-change aggregate metrics, cache and queue settings, test window, decision owner, and rollback status. Exclude contact details, document links, investment amounts, and raw payloads from the receipt.

Examples

In staging, replay a synthetic page sequence at low concurrency, then raise it one step while watching queue age and error percentage. If the destination returns a throttle response, reduce concurrency and verify that the retry queue drains without duplicating a synthetic record before considering a production canary.

Resources

• Finta Developer Docs
• Finta Blog

Next Steps

See finta-reference-architecture.