ServerlessConf 2026 in New York focused on production patterns for serverless and edge architectures. A recurring theme: UUID v7 has become the default identifier for stateless functions — replacing UUID v4 for primary keys and replacing custom timestamp+random schemes for idempotency keys. See UUID v7 in Serverless for the practical guide.

Event details

ConferenceServerlessConf 2026
DateApril 14–15, 2026
LocationNew York, NY, USA
FocusUUID v7 in Lambda, Cloudflare Workers, Deno Deploy, and edge architectures

Key sessions

UUID v7 in AWS Lambda

// handler.ts — Lambda function with UUID v7 trace ID
import { APIGatewayProxyHandler } from 'aws-lambda';
import { v7 as uuidv7 } from 'uuid';

export const handler: APIGatewayProxyHandler = async (event) => {
  // UUID v7 per-invocation trace ID — encodes invocation time
  const invocationId = uuidv7();

  // Check idempotency key if present
  const idempotencyKey = event.headers?.['idempotency-key'];
  if (idempotencyKey) {
    const existing = await checkIdempotency(idempotencyKey);
    if (existing) return existing;
  }

  const result = await processRequest(event, invocationId);
  return {
    statusCode: 201,
    headers: { 'X-Trace-ID': invocationId },
    body: JSON.stringify(result),
  };
};

See UUID in AWS Lambda.

UUID v7 in Cloudflare Workers

// Cloudflare Workers — UUID v7 with no cold start overhead
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const traceId = uuidv7(); // <1μs — no cold start impact

    if (request.method === 'POST') {
      const idempotencyKey = request.headers.get('Idempotency-Key');
      if (!idempotencyKey) {
        return new Response('Idempotency-Key required', { status: 400 });
      }

      // KV-backed idempotency using UUID v7 expiry
      const existing = await env.IDEMPOTENCY.get(idempotencyKey);
      if (existing) return Response.json(JSON.parse(existing));

      const orderId = uuidv7();
      const result = { orderId, status: 'created' };

      // TTL based on UUID v7 timestamp age
      const keyMs = parseInt(idempotencyKey.replace(/-/g, '').slice(0, 12), 16);
      const ageMs = Date.now() - keyMs;
      const ttl = Math.max(86400 - Math.floor(ageMs / 1000), 3600);

      await env.IDEMPOTENCY.put(idempotencyKey, JSON.stringify(result), { expirationTtl: ttl });
      return Response.json(result, { headers: { 'X-Trace-ID': traceId }, status: 201 });
    }

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

See UUID in Edge Functions.

Cross-region UUID v7 uniqueness

// Conference talk: UUID v7 across 200+ Cloudflare edge locations
// Each location generates IDs independently — 74 random bits prevent collisions.

// Proof: collision probability for 1 million concurrent Workers
// P(collision) ≈ n²/(2 × 2^74) = 10^12 / (2 × 1.89 × 10^22) ≈ 2.6 × 10^-11
// Effectively zero.

See UUID Collision Probability.

Idempotency at scale

// Serverless idempotency pattern: UUID v7 key + timestamp-based TTL
async function idempotentOperation<T>(
  key: string,           // UUID v7 from client
  operation: () => Promise<T>,
  store: KVStore,
): Promise<T> {
  const cached = await store.get<T>(key);
  if (cached) return cached;

  const result = await operation();

  // TTL derived from UUID v7 timestamp (24 hours from creation)
  const createdMs = parseInt(key.replace(/-/g, '').slice(0, 12), 16);
  const expiresAt = createdMs + 86_400_000;
  const ttlMs = Math.max(expiresAt - Date.now(), 3_600_000);

  await store.set(key, result, { ttlMs });
  return result;
}

Conference takeaways

  1. UUID v7 is stateless-safe — 74 random bits provide collision resistance across thousands of concurrent functions
  2. Zero cold-start impact — UUID v7 generation is sub-microsecond
  3. Timestamp-based TTLs — UUID v7 timestamps let idempotency stores expire keys naturally
  4. Cross-region ordering — UUID v7 from different regions sort by creation time when merged
  5. Drop the createdAt column — UUID v7 ID encodes creation time even in append-only logs

Further reading

External references

Frequently asked questions

Why is UUID v7 important for serverless functions?

Serverless functions are stateless and ephemeral — they cannot maintain an in-memory monotonic counter or database sequence for ID generation. UUID v7's 74 random bits provide collision resistance without coordination across function instances. The 48-bit timestamp prefix gives chronological ordering even when records from thousands of concurrent Lambda or Workers invocations are merged into a single database. See UUID v7 in Serverless.

Does UUID v7 generation add latency to cold starts?

UUID v7 generation is CPU-only with no I/O — it typically takes under 1 microsecond. The only overhead is the OS secure random call (crypto.getRandomValues() in runtimes that use it), which is negligible compared to network and database latency. On Lambda cold starts, UUID generation adds no measurable latency compared to the 100ms+ initialization overhead.

How does UUID v7 work as an idempotency key in serverless APIs?

Clients generate a UUID v7 before sending a request and include it as an Idempotency-Key header. The serverless function checks this key against a DynamoDB or Redis store before processing. UUID v7 timestamps let you set natural TTLs on idempotency records — a key for a request created 25 hours ago can safely expire. See UUID as Idempotency Keys.