Serverless Functions for Your Site (Netlify)

Your JAMstack site is growing, and it's time to add server-side logic without a dedicated backend. Netlify Functions are serverless handlers that deploy alongside your frontend in minutes. Just create a file in netlify/functions/ and the function is ready. A typical problem: a contact form on a static site fails to send data, or you need to handle webhooks from external services. Instead of spinning up a separate server, we use Netlify Functions. Infrastructure cost is nearly zero, and automatic scaling removes headaches.

We have been writing serverless functions for Netlify since the platform launched. Over 5 years, we have implemented 50+ functions for 15 projects: form processing, PDF generation, webhook integrations with CRM and payment systems. Our engineers are JAMstack certified; we guarantee stable function performance under a load of 1000+ requests per minute.

Two types of functions

Sync Functions — standard request/response. Support Node.js 18+, Go, Rust. Timeout 10 seconds (free) / 26 seconds (Pro).

Background Functions — for long-running tasks (up to 15 minutes). Immediately return 202 Accepted, execution continues in the background. File naming: *.mts or *-background.ts.

How to choose between Sync and Background Functions?

Benefits and development speed

Netlify Functions deploy 3-5 times faster than a separate server on AWS EC2. You don't need to manage infrastructure: scaling, security patches, and load balancing happen automatically. This reduces administration costs by 2-3 times (saving $500–$2000/month compared to a dedicated server). Git repository integration allows you to deploy functions alongside the frontend with a single git push — no need to set up a separate CI/CD pipeline. Local development via netlify dev mimics the production environment. Cold start can be reduced using esbuild bundling and configuring Warm Functions on the Pro plan.

How to optimize cold start?

Cold start is the delay on the first function invocation when the execution environment is not ready. In Netlify Functions, it defaults to 200–500 ms. To reduce it to 50–100 ms, use esbuild for bundling (it combines dependencies into a single file) and choose the Pro plan with Warm Functions, which keeps functions warm. Also avoid monolithic dependencies: import only the needed modules.

Example sync function

File netlify/functions/contact.ts:

import type { Handler, HandlerEvent } from "@netlify/functions";

export const handler: Handler = async (event: HandlerEvent) => {
  if (event.httpMethod !== "POST") {
    return { statusCode: 405, body: "Method Not Allowed" };
  }

  const data = JSON.parse(event.body || "{}");
  const { name, email, message } = data;

  // Send via Netlify Email Integration or external API
  await fetch("https://api.sendgrid.com/v3/mail/send", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.SENDGRID_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      personalizations: [{ to: [{ email: "[email protected]" }] }],
      from: { email: "[email protected]" },
      subject: `Message from ${name}`,
      content: [{ type: "text/plain", value: `${name} (${email}): ${message}` }],
    }),
  });

  return {
    statusCode: 200,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ ok: true }),
  };
};

The function is accessible at /.netlify/functions/contact or via redirect. For example, using netlify.toml: redirect /api/contact to /.netlify/functions/contact.

Background Function for reports

// netlify/functions/generate-report-background.ts
import type { BackgroundHandler } from "@netlify/functions";

export const handler: BackgroundHandler = async (event) => {
  const { reportId } = JSON.parse(event.body || "{}");

  // Long operation: PDF generation, data processing
  const pdf = await generatePDFReport(reportId);

  // Save to S3 and notify user
  await uploadToS3(pdf, `reports/${reportId}.pdf`);
  await notifyUser(reportId);
};

netlify.toml configuration

[build]
  command = "npm run build"
  publish = "dist"
  functions = "netlify/functions"

[functions]
  node_bundler = "esbuild"
  included_files = ["templates/**"]

[dev]
  command = "npm run dev"
  port = 8888

node_bundler = "esbuild" speeds up builds and reduces bundle size by 40% compared to zip archive.

Environment variables

Netlify Dashboard → Site Settings → Environment variables. For local development, use a .env file:

SENDGRID_API_KEY=SG.xxx
DATABASE_URL=postgresql://...

Work process and scope of services

We perform the full cycle of serverless function development:

1. Analytics — defining required functions, their signatures, and integrations.
2. Design — architecture, choice of function types, cold start optimization.
3. Implementation — coding with esbuild bundling.
4. Testing — local launch via netlify dev, edge case verification.
5. Deployment — setting up automatic deployment via Git.

What is included (deliverables)

• Function code with error handling and logging
• netlify.toml and redirect configuration
• Environment variable setup
• Local and production testing
• Call and deployment documentation
• Access to repository and CI/CD pipeline
• 1-hour training session on maintenance
• 30-day support after project delivery

Timeframes and cost

Basic functions (form, webhook) with redirect configuration — 1–2 days, starting from $500. Complex integrations (PDF generation, external APIs) — from 3 days, starting from $1500. Contact us for a free consultation on your serverless architecture.

Official Netlify Functions documentation: Netlify Functions overview

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 в зависимости от сложности.