Skip to main content
skill CX Codex

vercel-cost-tuning — Claude Code skill for cutting Vercel spend

vercel-cost-tuning reads Vercel billing and finds where money leaks: function time, bandwidth, middleware calls. Use it before the next invoice.

MIT 1 installs ★ 2,935 updated 2026-11-01

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jeremylongshore/tons-of-skills-marketplace --skill vercel-cost-tuning -a claude-code
Open on GitHub

What vercel-cost-tuning does

The skill walks through Fluid Compute pricing and digs into the main cost drivers. Function CPU and memory, bandwidth from large responses, edge middleware that fires on every request, image transforms, and build minutes. It pulls usage via the Vercel API, then suggests changes in vercel.json and route code.

One path it takes: right-size memory per endpoint, so a lightweight JSON route gets 128 MB instead of the default. Another: move read-only handlers to Edge Functions and add s-maxage cache headers so cached routes never hit the function at all.

You need access to the Vercel billing dashboard and a $VERCEL_TOKEN for API calls. The skill also covers spend management: set a monthly budget, enable a hard stop, get email alerts at 50%, 75%, 90%, 100%. Middleware is a common surprise, since it runs on every matched request, so the skill scopes it with a matcher.

What it helps with

  • Pull current Vercel usage via API
  • Cut serverless execution time by right-sizing memory
  • Add edge caching so cached routes skip functions
  • Narrow middleware matcher to relevant paths
  • Set spend management budget and alerts

Example prompts for the agent

  • Analyze my Vercel billing and list the biggest cost drivers
  • Right-size function memory in vercel.json for my API routes
  • Set up spend management alerts at 75% and 100%

How to install vercel-cost-tuning

1Skills CLI (Vercel)

npx skills add jeremylongshore/tons-of-skills-marketplace --skill vercel-cost-tuning -a claude-code

2Manually: put the files in place

~/.claude/skills/vercel-cost-tuning/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/vercel-cost-tuning/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about vercel-cost-tuning

How do I install vercel-cost-tuning in Claude Code?

Run npx skills add jeremylongshore/tons-of-skills-marketplace --skill vercel-cost-tuning -a claude-code, then check ~/.claude/skills/vercel-cost-tuning/SKILL.md.

What does vercel-cost-tuning do?

It works through Vercel Fluid Compute pricing and finds reductions in function time, bandwidth, middleware invocations, image optimizations, and build minutes.

What do I need before running it?

Access to the Vercel billing dashboard and a Vercel API token. Knowing your deployment architecture helps, along with access to Vercel Analytics.

Source text

SKILL.md · MIT
---
name: vercel-cost-tuning
description: 'Optimize Vercel costs through plan selection, function efficiency, and
  usage monitoring.

  Use when analyzing Vercel billing, reducing function execution costs,

  or implementing spend management and budget alerts.

  Trigger with phrases like "vercel cost", "vercel billing",

  "reduce vercel costs", "vercel pricing", "vercel expensive", "vercel budget".

  '
allowed-tools: Read, Write, Edit, Bash(vercel:*), Bash(curl:*), Grep
version: 1.18.0
license: MIT
author: Jeremy Longshore <[email protected]>
tags:
- saas
- vercel
- cost-optimization
- billing
- monitoring
compatibility: Designed for Claude Code
---
# Vercel Cost Tuning

## Overview

Optimize Vercel costs by understanding the Fluid Compute pricing model, reducing function execution time, leveraging edge caching to avoid function invocations, and configuring spend management. Covers plan comparison, cost drivers, and monitoring.

## Prerequisites

- Access to Vercel billing dashboard
- Understanding of current deployment architecture
- Access to Vercel Analytics for usage patterns

## Instructions

### Step 1: Understand the Pricing Model

Vercel uses **Fluid Compute** pricing (for new projects):

| Resource | Hobby (Free) | Pro ($20/member/mo) | Enterprise |
|----------|-------------|---------------------|------------|
| Bandwidth | 100 GB | 1 TB included | Custom |
| Serverless Execution | 100 GB-hrs | 1000 GB-hrs included | Custom |
| Edge Function invocations | 500K | 1M included | Custom |
| Edge Middleware invocations | 1M | 1M included | Custom |
| Image Optimizations | 1000 | 5000 included | Custom |
| Builds per day | 6000 | 6000 | Custom |
| Concurrent builds | 1 | 1 (more available) | Custom |

**Fluid Compute billing breakdown:**

- **Active CPU time**: charged per ms of actual CPU usage
- **Provisioned memory**: charged per GB-second of allocated memory
- Benefit: you pay for actual work, not idle waiting (e.g., waiting for a database response)

### Step 2: Identify Cost Drivers

```bash
# Check usage via API
curl -s -H "Authorization: Bearer $VERCEL_TOKEN" \
  "https://api.vercel.com/v2/usage" | jq .

# Top cost drivers on Vercel:
# 1. Serverless function execution time (CPU + memory)
# 2. Bandwidth (large responses, unoptimized images)
# 3. Edge Middleware invocations (runs on EVERY request)
# 4. Image optimizations (each unique transform costs)
# 5. Build minutes (frequent deploys or slow builds)
```

### Step 3: Reduce Function Execution Costs

```typescript
// 1. Right-size function memory — don't over-allocate
// vercel.json
{
  "functions": {
    "api/lightweight.ts": { "memory": 128 },    // Simple JSON responses
    "api/standard.ts": { "memory": 512 },       // Database queries
    "api/heavy.ts": { "memory": 1024 }          // Image processing
  }
}

// 2. Move read-only endpoints to Edge Functions (cheaper, no cold starts)
// api/config.ts
export const config = { runtime: 'edge' };
export default function handler() {
  return Response.json({ features: ['a', 'b'] });
}

// 3. Cache function responses at the edge
// Eliminates function invocations entirely for cached routes
export default function handler(req, res) {
  res.setHeader('Cache-Control', 's-maxage=3600, stale-while-revalidate=86400');
  res.json(data);
}
```

### Step 4: Reduce Bandwidth Costs

```json
// vercel.json — compress and cache aggressively
{
  "headers": [
    {
      "source": "/static/(.*)",
      "headers": [
        { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" }
      ]
    }
  ],
  "images": {
    "sizes": [640, 750, 1080],
    "formats": ["image/avif", "image/webp"],
    "minimumCacheTTL": 86400
  }
}
```

Key bandwidth reducers:

- Use Vercel's image optimization (auto WebP/AVIF conversion)
- Set aggressive cache headers on static assets
- Use ISR to serve static HTML instead of SSR
- Compress API responses (Vercel auto-compresses with Brotli)

### Step 5: Optimize Middleware Costs

Middleware runs on **every matched request**. Minimize its scope:

```typescript
// middleware.ts — scope to specific paths only
export const config = {
  matcher: [
    // Only run middleware on API routes and protected pages
    '/api/:path*',
    '/dashboard/:path*',
    // Skip static files, images, and public assets
    '/((?!_next/static|_next/image|favicon.ico|public).*)',
  ],
};

export function middleware(request) {
  // Keep logic minimal — this runs on every matched request
  // Avoid: database queries, external API calls, heavy computation
  // Good: cookie checks, header modifications, redirects
}
```

### Step 6: Configure Spend Management

In the Vercel dashboard under **Settings > Billing > Spend Management**:

```
Default budget: $200/month on-demand usage
Options:
- Set custom budget limit
- Enable hard limit (pauses all projects when reached)
- Configure email alerts at 50%, 75%, 90%, 100%
```

```bash
# Check current usage against budget via API
curl -s -H "Authorization: Bearer $VERCEL_TOKEN" \
  "https://api.vercel.com/v2/usage?teamId=team_xxx" \
  | jq '{period: .period, bandwidth: .bandwidth, execution: .serverlessFunctionExecution}'
```

## Cost Optimization Checklist

| Action | Impact | Effort |
|--------|--------|--------|
| Add `s-maxage` cache headers | High — eliminates function invocations | Low |
| Use Edge Functions for simple endpoints | Medium — cheaper than serverless | Low |
| Right-size function memory | Medium — reduces GB-hr cost | Low |
| Scope middleware matcher | Medium — reduces edge invocations | Low |
| Enable image optimization | Medium — reduces bandwidth | Low |
| Use ISR instead of SSR | High — serves cached HTML | Medium |
| Optimize build speed | Low — reduces build minutes | Medium |
| Set spend management alerts | Safety — prevents surprise bills | Low |

## Output

- Function memory right-sized per endpoint
- Edge caching reducing function invocations
- Middleware scoped to minimize invocations
- Spend management configured with budget alerts
- Usage monitoring via API

## Error Handling

| Error | Cause | Solution |
|-------|-------|----------|
| Unexpected bill spike | Uncached high-traffic endpoint | Add `s-maxage` to the response |
| Projects paused | Hard spending limit reached | Increase limit or optimize usage |
| Image optimization quota exceeded | Too many unique image transforms | Reduce `sizes` array, increase cache TTL |
| Build minutes exceeded | Slow builds or too many deploys | Use `ignoreCommand` to skip non-code changes |

## Examples

### Reduce an invocation spike with a measurable rollback

For a high-traffic read endpoint, add a conservative `s-maxage` response policy in a preview deployment and compare invocation count, cache hit rate, and response correctness against the prior release using synthetic requests. Set spend alerts before rollout and avoid a hard account-wide pause unless the owner accepts its blast radius. If personalized content is accidentally cached, immediately roll back the header change, purge only the affected deployment cache where supported, and document the regression.

## Resources

- [Vercel Pricing](https://vercel.com/pricing)
- [Fluid Compute Pricing](https://vercel.com/docs/functions/usage-and-pricing)
- [Spend Management](https://vercel.com/docs/pricing#spend-management)
- [Limits](https://vercel.com/docs/limits)
- [Usage API](https://vercel.com/docs/rest-api)

## Next Steps

For reference architecture, see `vercel-reference-architecture`.

© Jeremy Longshore · MIT · jeremylongshore/tons-of-skills-marketplace

Similar skills

All skills for DevOps and infrastructure →

From the same set139

The whole set →
email-parser This skill helps configure email parsing tasks, produce setup files and code, and check the result. It activates when a request mentions email parser. CX Codex +1 1installs granola-webhooks-events granola-webhooks-events — a skill for building event-driven automations with Granola meeting data through Zapier. Process meeting events in real time and route them to custom handlers or external services. CX Codex +1 1installs granola-core-workflow-a granola-core-workflow-a configures meeting templates, chat recipes, and pre-call context inside Granola. Helps structure agendas and summaries for standups and customer calls. CX Codex +1 1installs monitoring-cross-chain-bridges monitoring-cross-chain-bridges tracks bridge TVL, volume, fees, and transfer status across networks. Use it to compare routes or inspect a cross-chain transaction. CX Codex +1 1installs linear-cost-tuning linear-cost-tuning analyzes Linear API consumption, trims GraphQL query complexity, and shifts redundant polling loops to push webhooks. CX Codex +1 1installs linear-prod-checklist linear-prod-checklist audits a Linear integration before launch, covering access, data, quotas, webhooks, recovery, and ownership. CX Codex +1 1installs linear-observability linear-observability collects metrics and alerts around a Linear integration: API calls, webhooks, queue, reconciliation. Tokens and issue text stay out of telemetry. CX Codex +1 1installs supabase-webhooks-events supabase-webhooks-events guides the setup of Supabase database webhooks, pg_net HTTP triggers, LISTEN/NOTIFY, and Edge Function handlers with HMAC signature verification. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open