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
| Conference | ServerlessConf 2026 |
| Date | April 14–15, 2026 |
| Location | New York, NY, USA |
| Focus | UUID 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 });
},
};
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
- UUID v7 is stateless-safe — 74 random bits provide collision resistance across thousands of concurrent functions
- Zero cold-start impact — UUID v7 generation is sub-microsecond
- Timestamp-based TTLs — UUID v7 timestamps let idempotency stores expire keys naturally
- Cross-region ordering — UUID v7 from different regions sort by creation time when merged
- Drop the
createdAtcolumn — UUID v7 ID encodes creation time even in append-only logs
Further reading
- UUID v7 in Serverless — Lambda, Functions, Edge
- UUID in Edge Functions
- UUID in AWS Lambda
- UUID as Idempotency Keys
- UUID v7 in Microservices — Trace IDs and Correlation
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.