Skip to main content Accueil Créateurs jeremylongshore tons-of-skills-marketplace vercel-reliability-patterns
vercel-reliability-patterns Implement reliability patterns for Vercel deployments including circuit breakers, retry logic, and graceful degradation.
Use when building fault-tolerant serverless functions, implementing retry strategies,
or adding resilience to production Vercel services.
Trigger with phrases like "vercel reliability", "vercel circuit breaker",
"vercel resilience", "vercel fallback", "vercel graceful degradation".
Aller à l'installation Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/jeremylongshore/tons-of-skills-marketplace --skill vercel-reliability-patternsLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Explorateur de fichiers
6 fichiers Plus depuis ce dépôt langchain-deploy-integration Deploy a LangChain 1.0 / LangGraph 1.0 app to Cloud Run, Vercel, or LangServe correctly — with timeouts sized for chain length, cold-start mitigation, SSE anti-buffering headers, and Secret Manager over .env. Use when prepping a first production deploy, debugging a stream that hangs behind a proxy, or diagnosing p99 latency spikes. Trigger with "langchain deploy", "langchain cloud run", "langchain vercel python", "langchain langserve", or "langchain docker".
langchain-langgraph-agents Build a correct LangGraph 1.0 ReAct agent with create_react_agent — typed tools, error propagation, recursion caps, and stop conditions that actually stop. Use when writing a first tool-calling agent, migrating from AgentExecutor or initialize_agent, or diagnosing an agent that loops on vague prompts. Trigger with "langgraph agent", "create_react_agent", "langgraph tool calling", "AgentExecutor migration", or "agent loop cost".
langchain-langgraph-human-in-loop Build LangGraph 1.0 human-in-the-loop approval flows with interrupt_before /
interrupt_after and Command(resume=...) — JSON-serializable state, clean
resume semantics, and UI wiring for approval decisions. Use when adding an
approval gate before an expensive tool call, wiring a Slack/web UI for agent
approvals, or debugging a graph that crashes on interrupt.
Trigger with "langgraph human in loop", "langgraph interrupt_before",
"langgraph approval flow", "Command resume", "langgraph HITL".
name vercel-reliability-patterns description Implement reliability patterns for Vercel deployments including circuit breakers, retry logic, and graceful degradation.
Use when building fault-tolerant serverless functions, implementing retry strategies,
or adding resilience to production Vercel services.
Trigger with phrases like "vercel reliability", "vercel circuit breaker",
"vercel resilience", "vercel fallback", "vercel graceful degradation".
allowed-tools Read, Write, Edit version 1.18.0 license MIT author Jeremy Longshore <jeremy@intentsolutions.io> tags ["saas","vercel","reliability","resilience","patterns"] compatibility Designed for Claude Code
Vercel Reliability Patterns
Overview
Build fault-tolerant Vercel deployments with circuit breakers, retry logic, graceful degradation, and instant rollback integration. Addresses reliability at two levels: function-level resilience (protecting against dependency failures) and deployment-level resilience (protecting against bad deploys).
Prerequisites
Vercel project deployed to production
Understanding of failure modes in serverless
External dependencies (databases, APIs) identified
Instructions
Step 1: Circuit Breaker for External Dependencies
type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN' ;
class CircuitBreaker {
private state : CircuitState = 'CLOSED' ;
private failures = 0 ;
private lastFailure = 0 ;
private readonly threshold : number ;
private readonly resetTimeMs : number ;
constructor (threshold = 5 , resetTimeMs = 30000 ) {
this .threshold = threshold;
this .resetTimeMs = resetTimeMs;
}
async call<T>(fn : () => Promise <T>, fallback : () => T): Promise <T> {
if (this
state
'OPEN'
if
Date
now
this
lastFailure
this
resetTimeMs
this
state
'HALF_OPEN'
else
console
warn
'Circuit OPEN — returning fallback'
return
fallback
try
const
await
fn
this
onSuccess
return
catch
this
onFailure
console
error
'Circuit breaker caught error:'
return
fallback
private
onSuccess
void
this
failures
0
this
state
'CLOSED'
private
onFailure
void
this
failures
this
lastFailure
Date
now
if
this
failures
this
threshold
this
state
'OPEN'
console
warn
`Circuit OPENED after ${this .failures} failures`
const
new
CircuitBreaker
3
30000
export
default
async
function
handler
req, res
const
await
call
() =>
user
findMany
take
10
() =>
json
degraded
length
0
Important for serverless: Circuit breaker state lives in a single function instance. Different instances have independent circuits. For global circuit state, use Vercel KV or Edge Config.
Step 2: Retry with Exponential Backoff
interface RetryOptions {
maxRetries ?: number ;
baseDelayMs ?: number ;
maxDelayMs ?: number ;
retryOn ?: (error : unknown boolean ;
}
async function withRetry<T>(
fn : () => Promise <T>,
options : RetryOptions = {}
): Promise <T> {
const { maxRetries = 3 , baseDelayMs = 200 , maxDelayMs = 5000 , retryOn } = options;
for (let attempt = 0 ; attempt <= maxRetries; attempt++) {
try {
return await fn ();
} catch (error) {
if (attempt === maxRetries) throw error;
if (retryOn && !retryOn (error)) throw error;
const delay = Math .min (
baseDelayMs * Math .pow (2 , attempt) + Math .random () * 200 ,
maxDelayMs
);
await new Promise (r =>setTimeout (r, delay));
}
}
throw new Error ('Unreachable' );
}
const data = await withRetry (
() => fetch ('https://api.example.com/data' ).then (r =>if (!r.ok ) throw new Error (`HTTP ${r.status} ` );
return r.json ();
}),
{
maxRetries : 3 ,
retryOn : (err ) => {
if (err instanceof TypeError ) return true ;
return err.message ?.includes ('5' );
},
}
);
Step 3: Graceful Degradation with Stale Cache
import { get, set } from '@vercel/kv' ;
export default async function handler (req, res ) {
const cacheKey = 'products:latest' ;
try {
const freshData = await fetchProductsFromDB ();
await set (cacheKey, JSON .stringify (freshData), { ex : 3600 });
res.setHeader ('x-data-source' , 'live' );
res.json (freshData);
} catch (error) {
const cachedData = await get (cacheKey);
if (cachedData) {
console .warn ('Serving stale cache — primary source unavailable' );
res.setHeader ('x-data-source' , 'cache-stale' );
res.json (JSON .parse (cachedData as string ));
} else {
res.setHeader ('x-data-source' , 'degraded' );
res.status (503 ).json ({
error : 'Service temporarily unavailable' ,
degraded : true ,
});
}
}
}
Step 4: Idempotency Keys for Mutations
import { NextRequest , NextResponse } from 'next/server' ;
import { db } from '@/lib/db' ;
export async function POST (request : NextRequest const idempotencyKey = request.headers .get ('idempotency-key' );
if (!idempotencyKey) {
return NextResponse .json (
{ error : 'idempotency-key header required' },
{ status : 400 }
);
}
const existing = await db.idempotencyRecord .findUnique ({
where : { key : idempotencyKey },
});
if (existing) {
return NextResponse .json (JSON .parse (existing.responseBody ), {
status : existing.responseStatus ,
headers : { 'x-idempotent-replay' : 'true' },
});
}
const body = await request.json ();
const order = await db.order .create ({ data : body });
const responseBody = JSON .stringify ({ order });
await db.idempotencyRecord .create ({
data : { key : idempotencyKey, responseStatus : 201 , responseBody },
});
return NextResponse .json ({ order }, { status : 201 });
}
Step 5: Health Check with Dependency Status
export const dynamic = 'force-dynamic' ;
interface HealthCheck {
name : string ;
check : () => Promise <boolean >;
}
const checks : HealthCheck [] = [
{
name : 'database' ,
check : async () => {
await db.$queryRaw `SELECT 1` ;
return true ;
},
},
{
name : 'cache' ,
check : async () => {
await kv.ping ();
return true ;
},
},
{
name : 'external-api' ,
check : async () => {
const r = await fetch ('https://api.example.com/health' , { signal : AbortSignal .timeout (3000 ) });
return r.ok ;
},
},
];
export async function GET (const results : Record <string , 'ok' | 'error' > = {};
await Promise .all (
checks.map (async ({ name, check }) => {
try {
await check ();
results[name] = 'ok' ;
} catch {
results[name] = 'error' ;
}
})
);
const healthy = Object .values (results).every (v =>'ok' );
return Response .json (
{ status : healthy ? 'healthy' : 'degraded' , checks : results },
{ status : healthy ? 200 : 503 }
);
}
Step 6: Deployment-Level Resilience
DEPLOY_URL=$(vercel --prod)
HEALTH=$(curl -s -o /dev/null -w "%{http_code}" "$DEPLOY_URL /api/health" )
if [ "$HEALTH " != "200" ]; then
echo "Health check failed ($HEALTH ) — rolling back"
vercel rollback
exit 1
fi
echo "Deployment healthy"
Reliability Patterns Summary Pattern Protects Against Vercel Implementation Circuit breaker Dependency degradation In-function state or Edge Config Retry + backoff Transient failures withRetry wrapper Stale cache Primary source outage Vercel KV with TTL Idempotency Duplicate mutations Database record per request Health checks Bad deployments /api/health + rollback automationInstant rollback Deployment regression vercel rollback in CI
Output
Circuit breaker protecting all external dependency calls
Retry logic with exponential backoff for transient failures
Graceful degradation serving stale data when primary fails
Idempotency preventing duplicate mutations
Automated health check + rollback pipeline
Error Handling Error Cause Solution Circuit opens too aggressively Threshold too low Increase failure threshold (e.g., 5 → 10) Retry causes duplicate side effects No idempotency Add idempotency-key to mutation endpoints Stale cache expired TTL too short or never populated Increase TTL, seed cache on deploy Health check false positive Timeout too short Increase AbortSignal timeout to 5s Rollback reverts good deployment Flaky health check Add retry to health check before rollback
Resources
Next Steps For policy guardrails, see vercel-policy-guardrails.
