The instinct to discard aging monolithic backends (PHP, CodeIgniter, legacy Django/Rails) and initiate a ground-up rewrite is one of the most hazardous traps in software engineering. Monolithic codebases accumulate hundreds of implicit business edge-cases over years. Rewrites take longer than projected, freeze product development, and inevitably produce parity gaps during release cutovers.

The proven alternative is Martin Fowler's **Strangler Fig Pattern**, executed at the global edge.

## The Cloudflare Workers Edge Facade

By positioning a lightweight Cloudflare Worker in front of both the legacy origin and modern serverless microservices, engineering teams achieve granular routing control without touching DNS records:

```typescript
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // Route modernized endpoints to Cloudflare Workers / D1 API plane
    if (url.pathname.startsWith('/api/v1/projects') || url.pathname.startsWith('/api/v1/intake')) {
      return env.MODERN_API.fetch(request);
    }

    // Pass unmigrated legacy endpoints through to the legacy origin
    return fetch(
      new Request(`https://legacy-origin.internal${url.pathname}${url.search}`, request)
    );
  },
};
```

## Perimeter Contract Enforcement

Legacy systems often lack payload validation, passing malformed input directly into database queries. The edge facade enforces strict runtime contracts:

```typescript
// Contract-first perimeter validation with Zod v4
const result = ProjectBriefSchema.safeParse(await request.json());
if (!result.success) {
  return Response.json(
    { error: 'Validation failed', issues: result.error.issues },
    { status: 400 }
  );
}
```

This guarantees that newly extracted microservices never inherit dirty data, while the legacy origin is shielded from malicious or unvalidated requests.

## Dual-Writing & Shadow Verification

Before routing 100% of production traffic to newly modernized endpoints, deploy shadow traffic verification:

```typescript
// Asynchronously mirror requests to modernized endpoints without blocking response
ctx.waitUntil(
  (async () => {
    const [legacyRes, modernRes] = await Promise.all([
      fetch(legacyReq.clone()),
      env.MODERN_API.fetch(modernReq.clone()),
    ]);
    assertEquivalence(await legacyRes.json(), await modernRes.json());
  })()
);
```