Self-Hosted vs Managed Placeholder API: Cost and Ops

When self-hosting makes sense

Legitimate reasons to run a self hosted image api

Privacy-sensitive applications that cannot make requests to third-party services have a genuine reason to self-host. This includes applications subject to GDPR restrictions on data processor agreements, healthcare applications operating under HIPAA, and air-gapped enterprise deployments.

Applications that need placeholder images with custom internal branding — company logo watermarks, internal color palettes not available in a public API — may also need a self-hosted solution if the managed service does not expose those parameters.

Finally, organizations with strict security policies that forbid embedding third-party URLs in their CSP img-src directive may self-host to avoid the whitelist approval process. Adding a new domain to the CSP requires a security review at many organizations; a URL on the organization's own domain does not.

Self-hosting on Workers

Deploying a placeholder generator on Cloudflare Workers

A Cloudflare Worker that generates SVG placeholders requires no external dependencies. Parse the URL path for width, height, and color parameters, render an SVG string, and return it with the correct content-type and cache-control headers. The entire function fits in under 100 lines of TypeScript.

Cloudflare Workers free tier allows 100,000 requests per day with zero infrastructure cost. The Worker is deployed globally to all Cloudflare PoPs automatically. For a small to mid-size application, the free tier is sufficient and the operational overhead is minimal after initial setup.

The catch is feature development. When you need a new route — blur, skeleton, avatar with initials, thumbnail — you write and deploy it. Each new feature requires design decisions, implementation, testing, and ongoing maintenance. A managed service amortizes this cost across all users.

// Minimal Cloudflare Worker placeholder generator
export default {
  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);
    const [w, h] = url.pathname.replace('/', '').split('x').map(Number);
    if (!w || !h || w > 4096 || h > 4096) {
      return new Response('Invalid dimensions', { status: 400 });
    }
    const bg = url.searchParams.get('bg') ?? 'E4E4E7';
    const fg = url.searchParams.get('fg') ?? 'A1A1AA';
    const text = url.searchParams.get('text') ?? `${w} × ${h}`;
    const fontSize = Math.round(Math.min(w, h) * 0.08);

    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}">
  <rect width="100%" height="100%" fill="#${bg}"/>
  <text x="50%" y="50%" font-family="system-ui" font-size="${fontSize}"
    fill="#${fg}" text-anchor="middle" dominant-baseline="middle">
    ${text}
  </text>
</svg>`;

    return new Response(svg, {
      headers: {
        'Content-Type': 'image/svg+xml',
        'Cache-Control': 'public, max-age=31536000, immutable',
      },
    });
  },
};

Operational costs

Hidden costs of running your own placeholder infrastructure

Compute and bandwidth on Cloudflare Workers free tier are effectively zero. But compute is not the main cost. The main cost is developer time: initial setup, monitoring alerts, deployment pipelines, format support (adding JPEG/PNG/WebP output requires image encoding libraries that add bundle size and complexity to a Worker), and handling edge cases like oversized dimensions, malformed hex colors, or text injection in query parameters.

Security is also a cost. A public-facing image generation API that accepts arbitrary text in URL parameters needs input validation, output encoding, and consideration of SVG injection vectors. A managed service has already solved these problems; a self-hosted service must solve them each time.

Version management is another ongoing cost. Cloudflare Workers, Node.js, and Docker all receive security updates. A self-hosted service that is not actively updated accumulates dependency debt.

Managed advantages

What a managed placeholder service provides beyond generation

A managed service maintains the full feature surface: blur, skeleton animation, avatar, thumbnail, banner, JPEG/PNG/WebP format output, LQIP presets, dark mode defaults. New features are added without any work on your side. Edge caching with immutable headers is configured correctly from day one.

Managed services also absorb abuse protection. A public image generation endpoint will receive bot traffic, crawler traffic, and occasional intentional abuse — extremely large dimensions, millions of rapid requests, malformed inputs. A managed service has rate limiting and abuse detection built in.

For most applications, the managed approach is the right default. Self-hosting is justified when a specific compliance, branding, or security constraint cannot be met by a managed service.

Migration

Moving from self-hosted to managed placeholder API

If you have an existing self-hosted placeholder service and want to migrate to a managed one, the migration is a URL base change. Map your existing URL parameters to the managed service's path structure. Because placeholder URLs are deterministic, you can do a rolling migration by redirecting old URLs to new ones at the reverse proxy or CDN layer.

Keep the self-hosted service running behind the redirect during migration to avoid broken images in server-rendered HTML that is already cached by browsers or CDNs. Deprecate the old URLs after your CDN's cache TTL expires.

# Nginx redirect from self-hosted to fallback.pics
# Old: /placeholder/400x300?bg=7C3AED&fg=FFFFFF
# New: https://fallback.pics/api/v1/400x300/7C3AED/FFFFFF

location /placeholder/ {
  rewrite ^/placeholder/([0-9]+)x([0-9]+)(.*)$ https://fallback.pics/api/v1/$1x$2$3 permanent;
}

Summary

Self-hosted vs managed: the default choice for most teams

For most web applications, a managed placeholder API is the right default. The operational overhead of running a self-hosted image generation service outweighs the benefits unless a specific compliance or constraint makes managed services off-limits. Use the hours saved to build features that users care about instead of maintaining infrastructure that users never see.

https://fallback.pics/docs/
https://fallback.pics/placeholder-image-api/
https://fallback.pics/blog/self-hosted-placeholder-image-api-cloudflare-workers/
https://fallback.pics/blog/rate-limiting-public-image-apis/