Implement Edge Middleware and Serverless Functions on Deno Deploy

When your site serves users across the globe, latency becomes critical. Each roundtrip to the origin server adds hundreds of milliseconds, worsening LCP and TTFB. Edge Functions on Deno Deploy solve this by executing code at the periphery — in 35+ regions, on V8 Isolates with no cold start, directly improving Core Web Vitals. We build these functions turnkey: middleware, OG image generation, caching, authorization, and personalization at the network edge.

Our experience: 5+ years in edge development, 15+ turnkey projects. We guarantee stability and Core Web Vitals compliance. Unlike Lambda or Cloud Functions, code runs within milliseconds of the user because no container is spun up — the isolate is already warm. As documented by Deno Deploy docs, the platform uses V8 Isolates and eliminates cold starts.

Typical Tasks We Solve

• A/B testing at the CDN level
• Geo-location personalization
• Authorization middleware
• Request proxying with transformation
• Dynamic OG image generation

Comparison: Edge Functions vs Cloud Functions

Deno Deploy is up to 10x faster than AWS Lambda due to no cold starts and execution at the edge.

How Deno Deploy Works

Each function is an ES module with a Deno.serve handler. The platform does not support the file system (except bundle), no long setTimeout, and no background execution after response (except waitUntil).

// entry.ts
Deno.serve(async (req: Request) => {
  const url = new URL(req.url);

  if (url.pathname === '/api/geo') {
    const country = req.headers.get('x-deno-country') ?? 'unknown';
    const region = req.headers.get('x-deno-region') ?? 'unknown';

    return Response.json({ country, region });
  }

  return new Response('Not Found', { status: 404 });
});

Deploy via CLI with one command: deployctl deploy --project=my-site entry.ts.

Why Edge Functions Outperform Traditional Backends

The key advantage is no cold start and execution at the edge. Requests are handled in the user's region, reducing latency from 200–500 ms to 10–30 ms — improving LCP by up to 40%. This directly improves Core Web Vitals. Additionally, edge functions offload the origin server by handling caching and authorization without extra roundtrips.

Case: JWT Authentication Middleware

Often you need to verify a JWT before hitting the origin. On the edge, this happens without contacting the main server:

import { create, verify, getNumericDate } from 'https://deno.land/x/[email protected]/mod.ts';

const JWT_SECRET = Deno.env.get('JWT_SECRET')!;

async function getKey(secret: string): Promise<CryptoKey> {
  const enc = new TextEncoder();
  return await crypto.subtle.importKey(
    'raw',
    enc.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['sign', 'verify']
  );
}

Deno.serve(async (req: Request) => {
  const url = new URL(req.url);

  if (url.pathname.startsWith('/public') || url.pathname === '/') {
    return await fetch(req);
  }

  const authHeader = req.headers.get('Authorization');
  if (!authHeader?.startsWith('Bearer ')) {
    return new Response('Unauthorized', { status: 401 });
  }

  const token = authHeader.slice(7);

  try {
    const key = await getKey(JWT_SECRET);
    const payload = await verify(token, key);

    const modifiedReq = new Request(req, {
      headers: {
        ...Object.fromEntries(req.headers),
        'x-user-id': String(payload.sub),
        'x-user-role': String(payload.role ?? 'user'),
      },
    });

    return await fetch(modifiedReq);
  } catch {
    return new Response('Invalid token', { status: 401 });
  }
});

A common mistake is incorrect key import — use crypto.subtle.importKey with the correct format.

Integrating Edge Functions with Your Existing Site

Deno Deploy works as an Edge Layer before the origin. The flow is simple: DNS → Deno Deploy → Origin Server.

1. Configure DNS: point traffic to Deno Deploy (e.g., via CNAME to deno.dev or your own domain).
2. Write handler functions that decide whether to proxy to the backend, modify the request, or respond directly.
3. Deploy via CLI or GitHub Actions. No changes to your current backend are required.

{
  "tasks": {
    "dev": "deno run --allow-net --allow-env --watch entry.ts",
    "deploy": "deployctl deploy --project=my-site --prod entry.ts"
  },
  "imports": {
    "djwt": "https://deno.land/x/[email protected]/mod.ts"
  },
  "deploy": {
    "project": "my-site",
    "entrypoint": "entry.ts",
    "include": ["entry.ts", "lib/"]
  }
}

Case: OG Image Generation on the Edge

Satori — a library for rendering JSX to SVG — works in Deno Deploy. It generates unique preview images per page without prebuilding:

import satori from 'npm:[email protected]';
import { Resvg } from 'npm:@resvg/[email protected]';

Deno.serve(async (req: Request) => {
  const url = new URL(req.url);
  if (!url.pathname.startsWith('/og')) return new Response('Not Found', { status: 404 });

  const title = url.searchParams.get('title') ?? 'My Site';
  const description = url.searchParams.get('desc') ?? '';

  // Fetch the font from CDN (e.g., Inter-Bold)
  const fontResponse = await fetch('https://unpkg.com/@fontsource/[email protected]/files/inter-latin-700-normal.woff');
  const fontBuffer = await fontResponse.arrayBuffer();

  const svg = await satori(
    {
      type: 'div',
      props: {
        style: {
          display: 'flex',
          flexDirection: 'column',
          width: '100%',
          height: '100%',
          background: '#0f172a',
          padding: '60px',
          fontFamily: 'Inter',
        },
        children: [
          {
            type: 'h1',
            props: {
              style: { color: '#f8fafc', fontSize: 56, margin: 0, lineHeight: 1.2 },
              children: title,
            },
          },
          {
            type: 'p',
            props: {
              style: { color: '#94a3b8', fontSize: 28, marginTop: 24 },
              children: description,
            },
          },
        ],
      },
    },
    {
      width: 1200,
      height: 630,
      fonts: [{ name: 'Inter', data: fontBuffer, weight: 700, style: 'normal' }],
    }
  );

  const resvg = new Resvg(svg);
  const png = resvg.render().asPng();

  return new Response(png, {
    headers: {
      'Content-Type': 'image/png',
      'Cache-Control': 'public, max-age=86400, stale-while-revalidate=604800',
    },
  });
});

Case: Caching with Deno KV

Deno KV is a built-in key-value store with global replication. Useful for caching, counters, rate limiting:

const kv = await Deno.openKv();

Deno.serve(async (req: Request) => {
  const url = new URL(req.url);
  const cacheKey = ['cache', url.pathname + url.search];

  const cached = await kv.get<string>(cacheKey);
  if (cached.value) {
    return new Response(cached.value, {
      headers: {
        'Content-Type': 'application/json',
        'X-Cache': 'HIT',
      },
    });
  }

  const response = await fetch(`https://api.example.com${url.pathname}`);
  const data = await response.text();

  await kv.set(cacheKey, data, { expireIn: 5 * 60 * 1000 });

  return new Response(data, {
    headers: {
      'Content-Type': 'application/json',
      'X-Cache': 'MISS',
    },
  });
});

What's Included in the Work

• Analysis of edge scenarios and architecture selection
• Development of functions with tests and CI/CD
• Documentation of deployed functions and integration details
• Access to monitoring and logs
• Post-deployment support for 30 days
• Training session for your team (up to 2 hours)

Our Development Process

With over 5 years of experience and 15+ completed projects, we have a proven track record. Leave a request — we will evaluate your project within 1 day. Contact us to discuss tasks and timelines. Order an Edge Layer turnkey with performance guarantee.

Estimated Timelines and Investment

• Simple Edge Function (redirect, geolocation, basic middleware): 1–2 days, from $500.
• Middleware with JWT verification and proxying: 2–3 days, from $1,500.
• OG image generation with caching via Deno KV: 3–5 days, from $2,500.
• Full Edge Layer with rate limiting, A/B testing, analytics: 1–2 weeks, from $5,000.

Cost is calculated individually. Get a consultation from an engineer — we'll tell you which functions will bring the most performance gain.

Why Serverless Development? The Real Economics and Technical Trade-offs

Serverless does not mean "without servers". Servers exist—you just don't manage them. It's more accurate to think of it as "without server management": no OS patching, no nginx configuration, no disk space monitoring. The function receives an event, processes it, and returns a response. The provider decides where to run it. Мы занимаемся serverless-архитектурой более 5 лет и реализовали 30+ проектов на AWS Lambda, Vercel Functions и Cloudflare Workers. Гарантируем, что ваша система масштабируется без переплат — при условии правильного выбора платформы и оптимизации холодного старта.

Cold start — Lambda's main pain point on Node.js. In VPC, cold start reached 10 seconds before recent improvements. For production functions with latency requirements: Provisioned Concurrency (keeps instances warm), SnapStart for Java, minimize bundle via tree-shaking. Our typical optimization reduces cold start from 3.2s to 400ms.

Practical case: an image processing function (resize, WebP conversion, upload to S3). Bundle with sharp was 40MB due to native binaries. Solution: Lambda Layer with sharp, main function 800KB. Cold start dropped from 3.2s to 400ms. Lambda Layers — shared dependencies between functions. Up to 5 layers per function, each up to 250MB. Standard practice: layer with heavy dependencies (sharp, puppeteer, ffmpeg), layer with common business logic. Infrastructure for Lambda via AWS CDK or Terraform. SAM — for beginners, CDK — for serious projects with type safety.

Edge Runtime is fundamentally different: the function runs on a V8 isolate in the nearest Vercel CDN point (120+ regions). No cold start as such — the isolate starts in ~0ms. But strict limitations: no Node.js API (fs, crypto via Web API), no database access via TCP (only via HTTP API), bundle size up to 4MB. Edge Runtime is ideal for: middleware (auth check, redirect, A/B test), response transformations, geolocation logic, Edge Config. Not suitable for: accessing PostgreSQL, heavy computations, file system operations.

Cloudflare Workers run on V8 isolates in 300+ points of presence. Latency for the user is literally the nearest data center. Cold start < 1ms. Workers Durable Objects solve the state problem at the edge: each Durable Object is a single coordination point, running in one region. Ideal for: game rooms, real-time documents, rate limiting without races. Workers KV — eventually consistent storage. Writes propagate to all regions in ~60 seconds. Not suitable for financial transactions, suitable for configs, feature flags, cache. D1 — SQLite on the edge. Works great on a single read replica, write latency depends on distance to primary region. Not ideal for global write-heavy applications.

Ecosystem: Hono.js — a minimalist router that works on Workers, Deno, Bun, Node.js. Good choice if you need unified code for edge and server.

Vendor lock-in — a real problem. Lambda-specific code (handler signature, Lambda context) is hard to port. Hono.js, Remix, or adapters like @hono/node-server help keep logic portable. Мы проектируем абстракции, позволяющие сменить провайдера с минимальными изменениями.

How We Optimize Cold Start in AWS Lambda?

Cold start is Lambda's worst enemy. Here’s a step‑by‑step optimisation checklist we apply:

1. Minimise bundle size — tree‑shake dependencies, use Lambda Layers for native binaries (sharp, puppeteer). Target < 1MB.
2. Enable Provisioned Concurrency for latency‑critical functions — costs extra but cuts cold start to near zero.
3. Use SnapStart for Java (Lambda) — reduces init time by 90%+.
4. Avoid VPC unless necessary — if you need VPC, use AWS PrivateLink or Elastic Network Interface optimisation.
5. Warm‑up strategies — scheduler pinging function every 5 minutes (but only for low‑volume functions, otherwise Provisioned Concurrency cheaper).

Result: our clients typically see cold start drop from 2–4s to under 500ms. For a fintech API handling 50k requests/day, that means 3 fewer seconds of latency per request during peak scale.

When Does Serverless Not Fit? Cost Comparison

Serverless saves money when traffic is unpredictable or sparse — up to 70% reduction compared to dedicated servers. But it becomes expensive under constant high load. Example: a function processing 1 million requests/day at 300ms each costs about $100–200/month on Lambda. Equivalent EC2 instance might cost $50/month. For such steady workloads, Fargate or EC2 is cheaper.

Long computations (>15 min on Lambda, >30s on Vercel) require Fargate or a regular server. WebSocket server with state — no persistent process. Tasks with frequent disk access — ephemeral storage, /tmp on Lambda 512MB–10GB.

What’s Included in Serverless Development Service?

Мы предлагаем serverless-разработку под ключ. В каждый проект входит:

• Архитектурная документация (схема event‑driven потоков, выбор платформы, justification).
• Реализация функций с unit‑ и integration‑тестами.
• CI/CD pipeline (GitHub Actions / GitLab CI) с preview‑деплоями.
• Infrastructure as Code (Terraform / AWS CDK / Pulumi).
• Мониторинг и observability (OpenTelemetry, structured logging, distributed tracing).
• 30‑дневная пост‑релизная поддержка и оптимизация производительности.

Typical Mistakes in Serverless Development and How We Avoid Them

• Ignoring cold start — we measure and budget for it from day one.
• Over‑engineering state — many teams try to use Workers Durable Objects for simple caching; KV is often enough.
• No distributed tracing — without trace IDs across SQS › Lambda › DynamoDB streams, debugging is blind. We integrate AWS X‑Ray or OpenTelemetry automatically.
• Underestimating cost at scale — we simulate load patterns and compare serverless vs. container costs before committing.

Закажите serverless архитектуру под ключ — свяжитесь с нами для бесплатной оценки вашего проекта. Сроки: от 2 недель для MVP, до 10 недель для миграции монолита. Стоимость рассчитывается индивидуально, ориентировочно от $2,000 до $15,000 в зависимости от сложности.