instantly-performance-tuning
Optimize Instantly API performance with caching, batching, and connection pooling.Use when experiencing slow API responses, implementing caching strategies,or optimizing request throughput for Instantly integrations.Trigger with phrases like "instantly performance", "optimize instantly","instantly latency", "instantly caching", "instantly slow", "instantly batch".
When & Why to Use This Skill
The Instantly Performance Tuning skill is a specialized developer utility designed to optimize API interactions with the Instantly platform. It provides production-ready implementations for caching, request batching, and connection pooling, specifically engineered to reduce latency, prevent rate-limiting issues, and improve the overall throughput of sales automation integrations.
Use Cases
- Reducing API response times by implementing LRU or Redis-based caching for frequently accessed lead data and campaign stats.
- Optimizing high-volume data writes and reads using DataLoader to batch multiple requests, significantly reducing network overhead.
- Improving application stability in high-concurrency environments by configuring persistent connection pooling and keep-alive agents.
- Efficiently processing large-scale datasets through optimized pagination strategies and async generators to prevent memory pressure.
- Monitoring and benchmarking API performance to identify bottlenecks in production sales outreach workflows.
| name | instantly-performance-tuning |
|---|---|
| description | | |
| allowed-tools | Read, Write, Edit |
| version | 1.0.0 |
| license | MIT |
| author | Jeremy Longshore <jeremy@intentsolutions.io> |
Instantly Performance Tuning
Overview
Optimize Instantly API performance with caching, batching, and connection pooling.
Prerequisites
- Instantly SDK installed
- Understanding of async patterns
- Redis or in-memory cache available (optional)
- Performance monitoring in place
Latency Benchmarks
| Operation | P50 | P95 | P99 |
|---|---|---|---|
| Read | 50ms | 150ms | 300ms |
| Write | 100ms | 250ms | 500ms |
| List | 75ms | 200ms | 400ms |
Caching Strategy
Response Caching
import { LRUCache } from 'lru-cache';
const cache = new LRUCache<string, any>({
max: 1000,
ttl: 60000, // 1 minute
updateAgeOnGet: true,
});
async function cachedInstantlyRequest<T>(
key: string,
fetcher: () => Promise<T>,
ttl?: number
): Promise<T> {
const cached = cache.get(key);
if (cached) return cached as T;
const result = await fetcher();
cache.set(key, result, { ttl });
return result;
}
Redis Caching (Distributed)
import Redis from 'ioredis';
const redis = new Redis(process.env.REDIS_URL);
async function cachedWithRedis<T>(
key: string,
fetcher: () => Promise<T>,
ttlSeconds = 60
): Promise<T> {
const cached = await redis.get(key);
if (cached) return JSON.parse(cached);
const result = await fetcher();
await redis.setex(key, ttlSeconds, JSON.stringify(result));
return result;
}
Request Batching
import DataLoader from 'dataloader';
const instantlyLoader = new DataLoader<string, any>(
async (ids) => {
// Batch fetch from Instantly
const results = await instantlyClient.batchGet(ids);
return ids.map(id => results.find(r => r.id === id) || null);
},
{
maxBatchSize: 100,
batchScheduleFn: callback => setTimeout(callback, 10),
}
);
// Usage - automatically batched
const [item1, item2, item3] = await Promise.all([
instantlyLoader.load('id-1'),
instantlyLoader.load('id-2'),
instantlyLoader.load('id-3'),
]);
Connection Optimization
import { Agent } from 'https';
// Keep-alive connection pooling
const agent = new Agent({
keepAlive: true,
maxSockets: 10,
maxFreeSockets: 5,
timeout: 30000,
});
const client = new InstantlyClient({
apiKey: process.env.INSTANTLY_API_KEY!,
httpAgent: agent,
});
Pagination Optimization
async function* paginatedInstantlyList<T>(
fetcher: (cursor?: string) => Promise<{ data: T[]; nextCursor?: string }>
): AsyncGenerator<T> {
let cursor: string | undefined;
do {
const { data, nextCursor } = await fetcher(cursor);
for (const item of data) {
yield item;
}
cursor = nextCursor;
} while (cursor);
}
// Usage
for await (const item of paginatedInstantlyList(cursor =>
instantlyClient.list({ cursor, limit: 100 })
)) {
await process(item);
}
Performance Monitoring
async function measuredInstantlyCall<T>(
operation: string,
fn: () => Promise<T>
): Promise<T> {
const start = performance.now();
try {
const result = await fn();
const duration = performance.now() - start;
console.log({ operation, duration, status: 'success' });
return result;
} catch (error) {
const duration = performance.now() - start;
console.error({ operation, duration, status: 'error', error });
throw error;
}
}
Instructions
Step 1: Establish Baseline
Measure current latency for critical Instantly operations.
Step 2: Implement Caching
Add response caching for frequently accessed data.
Step 3: Enable Batching
Use DataLoader or similar for automatic request batching.
Step 4: Optimize Connections
Configure connection pooling with keep-alive.
Output
- Reduced API latency
- Caching layer implemented
- Request batching enabled
- Connection pooling configured
Error Handling
| Issue | Cause | Solution |
|---|---|---|
| Cache miss storm | TTL expired | Use stale-while-revalidate |
| Batch timeout | Too many items | Reduce batch size |
| Connection exhausted | No pooling | Configure max sockets |
| Memory pressure | Cache too large | Set max cache entries |
Examples
Quick Performance Wrapper
const withPerformance = <T>(name: string, fn: () => Promise<T>) =>
measuredInstantlyCall(name, () =>
cachedInstantlyRequest(`cache:${name}`, fn)
);
Resources
Next Steps
For cost optimization, see instantly-cost-tuning.