Strangler Fig Pattern

Evolution over revolution - migrate safely and incrementally

By Vishnu Darshan Sanku · Updated September 25, 2026

What is the Strangler Fig Pattern?

The Strangler Fig Pattern is a migration strategy for gradually replacing legacy systems without risky big-bang rewrites. Instead of replacing everything at once, you build new functionality alongside the old system, gradually route traffic to the new system, and eventually decommission the legacy system.

Risky big bang rewrite replacing everything at once compared with the strangler fig pattern of gradual incremental migration

Imagine you have an old tree house that needs to be replaced. Instead of tearing it down all at once (risky!), you build a new section next to the old one, move one room at a time to the new structure, keep the old parts working while building new ones, and eventually remove the old parts when everything is moved. This is exactly how the Strangler Fig Pattern works for software.

Real-World Scenario: The Big Rewrite Problem

Big rewrites fail frequently. Statistics show that 70% of large software rewrites fail. The average time for a “complete rewrite” is 2-3 years. During the rewrite, features are frozen and the business suffers. Many rewrites are abandoned mid-way due to scope creep.

Famous failures: Netscape 6 (1998-2000) attempted a complete rewrite and lost the browser market to Internet Explorer. Mozilla Thunderbird spent years on rewrites and never caught up. Twitter (2009-2011) attempted partial rewrites that caused major outages.

The problem: Big rewrites are high-risk, high-cost, and often fail. The Strangler Fig Pattern provides a safer, incremental alternative that reduces risk and allows continuous delivery of value.

How the Strangler Fig Pattern Works

Three Phases

Key Components

Facade/Proxy Layer
- Routes requests to either legacy or new system
- Gradually shifts traffic
- Transparent to clients
Legacy System
- Continues to run
- Gradually shrinks
- Eventually decommissioned
New System
- Built incrementally
- Runs alongside legacy
- Gradually expands

Step-by-Step Migration Strategy

Step 1: Identify Boundaries

Don’t extract randomly! Choose services with:

Good Candidates for Extraction

Leaf services (few dependencies): NotificationService only receives events and doesn’t depend on others. ReportingService is read-only and doesn’t affect core business. These are safe to extract first because they have minimal dependencies.

High-change areas (frequent updates): Pricing Engine has business rules that change often. Recommendation service has ML models updated frequently. Extracting these allows independent deployment and faster iteration.

Performance bottlenecks (need independent scaling): Search Service needs 50 instances. Image Processing is CPU-intensive and needs GPU. Extracting these allows independent scaling without scaling the entire monolith.

Clear business capabilities (well-defined boundaries): Payment Processing, User Authentication, and Order Management have clear boundaries. These are good candidates because they represent distinct business domains.

Bad Candidates for Extraction

Core entities with many dependents: User Service has everything depending on it—extract this later. Product Service is central to business logic. Extracting these early creates too many dependencies and increases risk.

Tightly coupled modules:

1
OrderLine          → Part of Order entity (extract together)
2
PaymentDetails     → Embedded in Payment

Incomplete business capabilities: “Order Validation” alone is part of Order Management. “Email Sending” alone is part of Notification Service. Don’t extract incomplete capabilities—extract complete business features.

Step 2: Create Abstraction Layer

Before extracting, create clear interfaces in the monolith.

💡 Tip: Click dropdown to switch between languages

1
# BEFORE: Direct implementation
2
class OrderService:
3
    def create_order(self, user_id: str, items: list) -> Order:
4
        # Direct database access
5
        user = db.query(User).get(user_id)
6

7
        # Create order
8
        order = Order(user_id=user_id, items=items)
9
        db.add(order)
10

11
        # Send notification (tightly coupled!)
12
        email_sender.send(user.email, "Order created", ...)
13
        sms_sender.send(user.phone, "Order created")
14

15
        return order
16

17
# AFTER: Interface abstraction
18
from abc import ABC, abstractmethod
19

20
class NotificationService(ABC):
21
    """Abstract interface for notifications"""
22
    @abstractmethod
23
    def notify_order_created(self, order: Order):
24
        pass
25

26
class LocalNotificationService(NotificationService):
27
    """Implementation using local email/SMS"""
28
    def notify_order_created(self, order: Order):
29
        email_sender.send(...)
30
        sms_sender.send(...)
31

32
class RemoteNotificationService(NotificationService):
33
    """Implementation calling external service"""
34
    def notify_order_created(self, order: Order):
35
        # Call microservice
36
        httpx.post(
37
            "http://notification-service/notify",
38
            json={"order_id": order.id, "type": "order_created"}
39
        )
40

41
class OrderService:
42
    def __init__(self, notification_service: NotificationService):
43
        self._notifier = notification_service  # Inject!
44

45
    def create_order(self, user_id: str, items: list) -> Order:
46
        user = db.query(User).get(user_id)
47
        order = Order(user_id=user_id, items=items)
48
        db.add(order)
49

50
        # Use abstraction (doesn't know if local or remote!)
51
        self._notifier.notify_order_created(order)
52

53
        return order

1
// BEFORE: Direct implementation
2
public class OrderService {
3
    public Order createOrder(String userId, List<Item> items) {
4
        User user = userRepository.findById(userId);
5

6
        Order order = new Order(userId, items);
7
        orderRepository.save(order);
8

9
        // Tightly coupled!
10
        emailSender.send(user.getEmail(), "Order created");
11
        smsSender.send(user.getPhone(), "Order created");
12

13
        return order;
14
    }
15
}
16

17
// AFTER: Interface abstraction
18
public interface NotificationService {
19
    void notifyOrderCreated(Order order);
20
}
21

22
public class LocalNotificationService implements NotificationService {
23
    @Override
24
    public void notifyOrderCreated(Order order) {
25
        emailSender.send(...);
26
        smsSender.send(...);
27
    }
28
}
29

30
public class RemoteNotificationService implements NotificationService {
31
    private final RestTemplate restTemplate;
32

33
    @Override
34
    public void notifyOrderCreated(Order order) {
35
        // Call microservice
36
        restTemplate.postForObject(
37
            "http://notification-service/notify",
38
            new NotifyRequest(order.getId(), "order_created"),
39
            Void.class
40
        );
41
    }
42
}
43

44
public class OrderService {
45
    private final NotificationService notificationService;
46

47
    public OrderService(NotificationService notificationService) {
48
        this.notificationService = notificationService;
49
    }
50

51
    public Order createOrder(String userId, List<Item> items) {
52
        User user = userRepository.findById(userId);
53
        Order order = new Order(userId, items);
54
        orderRepository.save(order);
55

56
        // Use abstraction (doesn't know if local or remote!)
57
        notificationService.notifyOrderCreated(order);
58

59
        return order;
60
    }
61
}

1
// BEFORE: Direct implementation
2
class OrderService {
3
    async createOrder(userId: string, items: Item[]): Promise<Order> {
4
        // Direct database access
5
        const user = await db.query(User).where({ id: userId }).first();
6

7
        // Create order
8
        const order = new Order(userId, items);
9
        await db.add(order);
10

11
        // Send notification (tightly coupled!)
12
        await emailSender.send(user.email, "Order created", ...);
13
        await smsSender.send(user.phone, "Order created");
14

15
        return order;
16
    }
17
}
18

19
// AFTER: Interface abstraction
20
interface NotificationService {
21
    notifyOrderCreated(order: Order): Promise<void>;
22
}
23

24
class LocalNotificationService implements NotificationService {
25
    async notifyOrderCreated(order: Order): Promise<void> {
26
        await emailSender.send(...);
27
        await smsSender.send(...);
28
    }
29
}
30

31
class RemoteNotificationService implements NotificationService {
32
    async notifyOrderCreated(order: Order): Promise<void> {
33
        // Call microservice
34
        await fetch("http://notification-service/notify", {
35
            method: "POST",
36
            headers: { "Content-Type": "application/json" },
37
            body: JSON.stringify({
38
                order_id: order.id,
39
                type: "order_created"
40
            })
41
        });
42
    }
43
}
44

45
class OrderService {
46
    constructor(private notificationService: NotificationService) {}
47

48
    async createOrder(userId: string, items: Item[]): Promise<Order> {
49
        const user = await db.query(User).where({ id: userId }).first();
50
        const order = new Order(userId, items);
51
        await db.add(order);
52

53
        // Use abstraction (doesn't know if local or remote!)
54
        await this.notificationService.notifyOrderCreated(order);
55

56
        return order;
57
    }
58
}

1
// BEFORE: Direct implementation
2
class OrderService {
3
public:
4
    Order createOrder(const std::string& userId, const std::vector<Item>& items) {
5
        // Direct database access
6
        User user = db->query<User>().where("id", userId).first();
7

8
        // Create order
9
        Order order(userId, items);
10
        db->add(order);
11

12
        // Send notification (tightly coupled!)
13
        emailSender->send(user.getEmail(), "Order created", ...);
14
        smsSender->send(user.getPhone(), "Order created");
15

16
        return order;
17
    }
18
};
19

20
// AFTER: Interface abstraction
21
class NotificationService {
22
public:
23
    virtual ~NotificationService() = default;
24
    virtual void notifyOrderCreated(const Order& order) = 0;
25
};
26

27
class LocalNotificationService : public NotificationService {
28
public:
29
    void notifyOrderCreated(const Order& order) override {
30
        emailSender->send(...);
31
        smsSender->send(...);
32
    }
33
};
34

35
class RemoteNotificationService : public NotificationService {
36
private:
37
    HttpClient* httpClient;
38

39
public:
40
    void notifyOrderCreated(const Order& order) override {
41
        // Call microservice
42
        HttpRequest request("http://notification-service/notify");
43
        request.setMethod("POST");
44
        request.setBody(Json::object{
45
            {"order_id", order.getId()},
46
            {"type", "order_created"}
47
        });
48
        httpClient->send(request);
49
    }
50
};
51

52
class OrderService {
53
private:
54
    NotificationService* notificationService;
55

56
public:
57
    OrderService(NotificationService* notificationService)
58
        : notificationService(notificationService) {}
59

60
    Order createOrder(const std::string& userId, const std::vector<Item>& items) {
61
        User user = db->query<User>().where("id", userId).first();
62
        Order order(userId, items);
63
        db->add(order);
64

65
        // Use abstraction (doesn't know if local or remote!)
66
        notificationService->notifyOrderCreated(order);
67

68
        return order;
69
    }
70
};

1
// BEFORE: Direct implementation
2
public class OrderService {
3
    public async Task<Order> CreateOrderAsync(string userId, List<Item> items) {
4
        // Direct database access
5
        User user = await db.Query<User>().Where(u => u.Id == userId).FirstAsync();
6

7
        // Create order
8
        Order order = new Order(userId, items);
9
        await db.AddAsync(order);
10

11
        // Send notification (tightly coupled!)
12
        await emailSender.SendAsync(user.Email, "Order created", ...);
13
        await smsSender.SendAsync(user.Phone, "Order created");
14

15
        return order;
16
    }
17
}
18

19
// AFTER: Interface abstraction
20
public interface INotificationService {
21
    Task NotifyOrderCreatedAsync(Order order);
22
}
23

24
public class LocalNotificationService : INotificationService {
25
    public async Task NotifyOrderCreatedAsync(Order order) {
26
        await emailSender.SendAsync(...);
27
        await smsSender.SendAsync(...);
28
    }
29
}
30

31
public class RemoteNotificationService : INotificationService {
32
    private readonly HttpClient httpClient;
33

34
    public async Task NotifyOrderCreatedAsync(Order order) {
35
        // Call microservice
36
        await httpClient.PostAsync(
37
            "http://notification-service/notify",
38
            new StringContent(JsonSerializer.Serialize(new {
39
                order_id = order.Id,
40
                type = "order_created"
41
            }))
42
        );
43
    }
44
}
45

46
public class OrderService {
47
    private readonly INotificationService notificationService;
48

49
    public OrderService(INotificationService notificationService) {
50
        this.notificationService = notificationService;
51
    }
52

53
    public async Task<Order> CreateOrderAsync(string userId, List<Item> items) {
54
        User user = await db.Query<User>().Where(u => u.Id == userId).FirstAsync();
55
        Order order = new Order(userId, items);
56
        await db.AddAsync(order);
57

58
        // Use abstraction (doesn't know if local or remote!)
59
        await notificationService.NotifyOrderCreatedAsync(order);
60

61
        return order;
62
    }
63
}

Step 3: Implement Facade/Proxy

Route traffic between legacy and new system.

💡 Tip: Click dropdown to switch between languages

1
from fastapi import FastAPI, Request
2
import httpx
3

4
app = FastAPI()
5

6
class StranglerRouter:
7
    def __init__(self):
8
        self._legacy_client = httpx.AsyncClient(
9
            base_url="http://legacy-monolith:8080"
10
        )
11
        self._new_client = httpx.AsyncClient(
12
            base_url="http://notification-service:8080"
13
        )
14

15
        # Feature flags control routing
16
        self._migrated_endpoints = {
17
            "/api/notifications": 100,  # 100% to new service
18
            "/api/orders": 50,          # 50% to new service
19
            "/api/users": 0,            # 0% to new service (still legacy)
20
        }
21

22
    async def route_request(self, request: Request):
23
        path = request.url.path
24

25
        # Check if endpoint is migrated
26
        migration_percentage = self._migrated_endpoints.get(path, 0)
27

28
        # Random routing based on percentage
29
        import random
30
        route_to_new = random.random() * 100 < migration_percentage
31

32
        client = self._new_client if route_to_new else self._legacy_client
33

34
        # Forward request
35
        response = await client.request(
36
            method=request.method,
37
            url=path,
38
            headers=dict(request.headers),
39
            content=await request.body()
40
        )
41

42
        return response
43

44
@app.api_route("/{full_path:path}", methods=["GET", "POST", "PUT", "DELETE"])
45
async def proxy(request: Request):
46
    router = StranglerRouter()
47
    return await router.route_request(request)

1
@RestController
2
public class StranglerRouter {
3

4
    private final RestTemplate legacyClient;
5
    private final RestTemplate newClient;
6
    private final Map<String, Integer> migratedEndpoints;
7

8
    public StranglerRouter() {
9
        this.legacyClient = new RestTemplate();
10
        this.legacyClient.setUriTemplateHandler(
11
            new DefaultUriBuilderFactory("http://legacy-monolith:8080")
12
        );
13

14
        this.newClient = new RestTemplate();
15
        this.newClient.setUriTemplateHandler(
16
            new DefaultUriBuilderFactory("http://notification-service:8080")
17
        );
18

19
        // Feature flags control routing
20
        this.migratedEndpoints = Map.of(
21
            "/api/notifications", 100,  // 100% to new service
22
            "/api/orders", 50,          // 50% to new service
23
            "/api/users", 0             // 0% to new service (still legacy)
24
        );
25
    }
26

27
    @RequestMapping("/**")
28
    public ResponseEntity<String> proxy(
29
        HttpServletRequest request,
30
        @RequestBody(required = false) String body
31
    ) {
32
        String path = request.getRequestURI();
33

34
        // Check if endpoint is migrated
35
        int migrationPercentage = migratedEndpoints.getOrDefault(path, 0);
36

37
        // Random routing based on percentage
38
        boolean routeToNew = Math.random() * 100 < migrationPercentage;
39

40
        RestTemplate client = routeToNew ? newClient : legacyClient;
41

42
        // Forward request
43
        HttpEntity<String> entity = new HttpEntity<>(body);
44
        return client.exchange(
45
            path,
46
            HttpMethod.valueOf(request.getMethod()),
47
            entity,
48
            String.class
49
        );
50
    }
51
}

1
// BEFORE: Direct implementation
2
class OrderService {
3
    async createOrder(userId: string, items: Item[]): Promise<Order> {
4
        // Direct database access
5
        const user = await db.query(User).where({ id: userId }).first();
6

7
        // Create order
8
        const order = new Order(userId, items);
9
        await db.add(order);
10

11
        // Send notification (tightly coupled!)
12
        await emailSender.send(user.email, "Order created", ...);
13
        await smsSender.send(user.phone, "Order created");
14

15
        return order;
16
    }
17
}
18

19
// AFTER: Interface abstraction
20
interface NotificationService {
21
    notifyOrderCreated(order: Order): Promise<void>;
22
}
23

24
class LocalNotificationService implements NotificationService {
25
    async notifyOrderCreated(order: Order): Promise<void> {
26
        await emailSender.send(...);
27
        await smsSender.send(...);
28
    }
29
}
30

31
class RemoteNotificationService implements NotificationService {
32
    async notifyOrderCreated(order: Order): Promise<void> {
33
        // Call microservice
34
        await fetch("http://notification-service/notify", {
35
            method: "POST",
36
            headers: { "Content-Type": "application/json" },
37
            body: JSON.stringify({
38
                order_id: order.id,
39
                type: "order_created"
40
            })
41
        });
42
    }
43
}
44

45
class OrderService {
46
    constructor(private notificationService: NotificationService) {}
47

48
    async createOrder(userId: string, items: Item[]): Promise<Order> {
49
        const user = await db.query(User).where({ id: userId }).first();
50
        const order = new Order(userId, items);
51
        await db.add(order);
52

53
        // Use abstraction (doesn't know if local or remote!)
54
        await this.notificationService.notifyOrderCreated(order);
55

56
        return order;
57
    }
58
}

1
// BEFORE: Direct implementation
2
class OrderService {
3
public:
4
    Order createOrder(const std::string& userId, const std::vector<Item>& items) {
5
        // Direct database access
6
        User user = db->query<User>().where("id", userId).first();
7

8
        // Create order
9
        Order order(userId, items);
10
        db->add(order);
11

12
        // Send notification (tightly coupled!)
13
        emailSender->send(user.getEmail(), "Order created", ...);
14
        smsSender->send(user.getPhone(), "Order created");
15

16
        return order;
17
    }
18
};
19

20
// AFTER: Interface abstraction
21
class NotificationService {
22
public:
23
    virtual ~NotificationService() = default;
24
    virtual void notifyOrderCreated(const Order& order) = 0;
25
};
26

27
class LocalNotificationService : public NotificationService {
28
public:
29
    void notifyOrderCreated(const Order& order) override {
30
        emailSender->send(...);
31
        smsSender->send(...);
32
    }
33
};
34

35
class RemoteNotificationService : public NotificationService {
36
private:
37
    HttpClient* httpClient;
38

39
public:
40
    void notifyOrderCreated(const Order& order) override {
41
        // Call microservice
42
        HttpRequest request("http://notification-service/notify");
43
        request.setMethod("POST");
44
        request.setBody(Json::object{
45
            {"order_id", order.getId()},
46
            {"type", "order_created"}
47
        });
48
        httpClient->send(request);
49
    }
50
};
51

52
class OrderService {
53
private:
54
    NotificationService* notificationService;
55

56
public:
57
    OrderService(NotificationService* notificationService)
58
        : notificationService(notificationService) {}
59

60
    Order createOrder(const std::string& userId, const std::vector<Item>& items) {
61
        User user = db->query<User>().where("id", userId).first();
62
        Order order(userId, items);
63
        db->add(order);
64

65
        // Use abstraction (doesn't know if local or remote!)
66
        notificationService->notifyOrderCreated(order);
67

68
        return order;
69
    }
70
};

1
// BEFORE: Direct implementation
2
public class OrderService {
3
    public async Task<Order> CreateOrderAsync(string userId, List<Item> items) {
4
        // Direct database access
5
        User user = await db.Query<User>().Where(u => u.Id == userId).FirstAsync();
6

7
        // Create order
8
        Order order = new Order(userId, items);
9
        await db.AddAsync(order);
10

11
        // Send notification (tightly coupled!)
12
        await emailSender.SendAsync(user.Email, "Order created", ...);
13
        await smsSender.SendAsync(user.Phone, "Order created");
14

15
        return order;
16
    }
17
}
18

19
// AFTER: Interface abstraction
20
public interface INotificationService {
21
    Task NotifyOrderCreatedAsync(Order order);
22
}
23

24
public class LocalNotificationService : INotificationService {
25
    public async Task NotifyOrderCreatedAsync(Order order) {
26
        await emailSender.SendAsync(...);
27
        await smsSender.SendAsync(...);
28
    }
29
}
30

31
public class RemoteNotificationService : INotificationService {
32
    private readonly HttpClient httpClient;
33

34
    public async Task NotifyOrderCreatedAsync(Order order) {
35
        // Call microservice
36
        await httpClient.PostAsync(
37
            "http://notification-service/notify",
38
            new StringContent(JsonSerializer.Serialize(new {
39
                order_id = order.Id,
40
                type = "order_created"
41
            }))
42
        );
43
    }
44
}
45

46
public class OrderService {
47
    private readonly INotificationService notificationService;
48

49
    public OrderService(INotificationService notificationService) {
50
        this.notificationService = notificationService;
51
    }
52

53
    public async Task<Order> CreateOrderAsync(string userId, List<Item> items) {
54
        User user = await db.Query<User>().Where(u => u.Id == userId).FirstAsync();
55
        Order order = new Order(userId, items);
56
        await db.AddAsync(order);
57

58
        // Use abstraction (doesn't know if local or remote!)
59
        await notificationService.NotifyOrderCreatedAsync(order);
60

61
        return order;
62
    }
63
}

Step 4: Extract Service (Build New)

Build the new service with its own database.

💡 Tip: Click dropdown to switch between languages

1
from fastapi import FastAPI
2
from sqlalchemy import create_engine
3
from sqlalchemy.orm import Session
4

5
app = FastAPI()
6

7
# Own database!
8
engine = create_engine("postgresql://localhost/notification_db")
9

10
@app.post("/notify")
11
async def notify(request: NotifyRequest):
12
    """New microservice implementation"""
13
    with Session(engine) as session:
14
        # Store notification in OWN database
15
        notification = Notification(
16
            order_id=request.order_id,
17
            type=request.type,
18
            status="pending"
19
        )
20
        session.add(notification)
21
        session.commit()
22

23
        # Send via external services
24
        await email_service.send(notification)
25
        await sms_service.send(notification)
26

27
        notification.status = "sent"
28
        session.commit()
29

30
    return {"status": "sent"}
31

32
@app.get("/notifications/{order_id}")
33
async def get_notifications(order_id: str):
34
    """Query OWN database"""
35
    with Session(engine) as session:
36
        notifications = session.query(Notification)\
37
            .filter_by(order_id=order_id)\
38
            .all()
39
        return notifications

1
@RestController
2
@RequestMapping("/")
3
public class NotificationController {
4

5
    // Own database!
6
    @Autowired
7
    private NotificationRepository notificationRepo;
8

9
    @Autowired
10
    private EmailService emailService;
11

12
    @Autowired
13
    private SmsService smsService;
14

15
    @PostMapping("/notify")
16
    public NotifyResponse notify(@RequestBody NotifyRequest request) {
17
        // Store notification in OWN database
18
        Notification notification = new Notification(
19
            request.getOrderId(),
20
            request.getType(),
21
            "pending"
22
        );
23
        notificationRepo.save(notification);
24

25
        // Send via external services
26
        emailService.send(notification);
27
        smsService.send(notification);
28

29
        notification.setStatus("sent");
30
        notificationRepo.save(notification);
31

32
        return new NotifyResponse("sent");
33
    }
34

35
    @GetMapping("/notifications/{orderId}")
36
    public List<Notification> getNotifications(@PathVariable String orderId) {
37
        // Query OWN database
38
        return notificationRepo.findByOrderId(orderId);
39
    }
40
}

1
// BEFORE: Direct implementation
2
class OrderService {
3
    async createOrder(userId: string, items: Item[]): Promise<Order> {
4
        // Direct database access
5
        const user = await db.query(User).where({ id: userId }).first();
6

7
        // Create order
8
        const order = new Order(userId, items);
9
        await db.add(order);
10

11
        // Send notification (tightly coupled!)
12
        await emailSender.send(user.email, "Order created", ...);
13
        await smsSender.send(user.phone, "Order created");
14

15
        return order;
16
    }
17
}
18

19
// AFTER: Interface abstraction
20
interface NotificationService {
21
    notifyOrderCreated(order: Order): Promise<void>;
22
}
23

24
class LocalNotificationService implements NotificationService {
25
    async notifyOrderCreated(order: Order): Promise<void> {
26
        await emailSender.send(...);
27
        await smsSender.send(...);
28
    }
29
}
30

31
class RemoteNotificationService implements NotificationService {
32
    async notifyOrderCreated(order: Order): Promise<void> {
33
        // Call microservice
34
        await fetch("http://notification-service/notify", {
35
            method: "POST",
36
            headers: { "Content-Type": "application/json" },
37
            body: JSON.stringify({
38
                order_id: order.id,
39
                type: "order_created"
40
            })
41
        });
42
    }
43
}
44

45
class OrderService {
46
    constructor(private notificationService: NotificationService) {}
47

48
    async createOrder(userId: string, items: Item[]): Promise<Order> {
49
        const user = await db.query(User).where({ id: userId }).first();
50
        const order = new Order(userId, items);
51
        await db.add(order);
52

53
        // Use abstraction (doesn't know if local or remote!)
54
        await this.notificationService.notifyOrderCreated(order);
55

56
        return order;
57
    }
58
}

1
// BEFORE: Direct implementation
2
class OrderService {
3
public:
4
    Order createOrder(const std::string& userId, const std::vector<Item>& items) {
5
        // Direct database access
6
        User user = db->query<User>().where("id", userId).first();
7

8
        // Create order
9
        Order order(userId, items);
10
        db->add(order);
11

12
        // Send notification (tightly coupled!)
13
        emailSender->send(user.getEmail(), "Order created", ...);
14
        smsSender->send(user.getPhone(), "Order created");
15

16
        return order;
17
    }
18
};
19

20
// AFTER: Interface abstraction
21
class NotificationService {
22
public:
23
    virtual ~NotificationService() = default;
24
    virtual void notifyOrderCreated(const Order& order) = 0;
25
};
26

27
class LocalNotificationService : public NotificationService {
28
public:
29
    void notifyOrderCreated(const Order& order) override {
30
        emailSender->send(...);
31
        smsSender->send(...);
32
    }
33
};
34

35
class RemoteNotificationService : public NotificationService {
36
private:
37
    HttpClient* httpClient;
38

39
public:
40
    void notifyOrderCreated(const Order& order) override {
41
        // Call microservice
42
        HttpRequest request("http://notification-service/notify");
43
        request.setMethod("POST");
44
        request.setBody(Json::object{
45
            {"order_id", order.getId()},
46
            {"type", "order_created"}
47
        });
48
        httpClient->send(request);
49
    }
50
};
51

52
class OrderService {
53
private:
54
    NotificationService* notificationService;
55

56
public:
57
    OrderService(NotificationService* notificationService)
58
        : notificationService(notificationService) {}
59

60
    Order createOrder(const std::string& userId, const std::vector<Item>& items) {
61
        User user = db->query<User>().where("id", userId).first();
62
        Order order(userId, items);
63
        db->add(order);
64

65
        // Use abstraction (doesn't know if local or remote!)
66
        notificationService->notifyOrderCreated(order);
67

68
        return order;
69
    }
70
};

1
// BEFORE: Direct implementation
2
public class OrderService {
3
    public async Task<Order> CreateOrderAsync(string userId, List<Item> items) {
4
        // Direct database access
5
        User user = await db.Query<User>().Where(u => u.Id == userId).FirstAsync();
6

7
        // Create order
8
        Order order = new Order(userId, items);
9
        await db.AddAsync(order);
10

11
        // Send notification (tightly coupled!)
12
        await emailSender.SendAsync(user.Email, "Order created", ...);
13
        await smsSender.SendAsync(user.Phone, "Order created");
14

15
        return order;
16
    }
17
}
18

19
// AFTER: Interface abstraction
20
public interface INotificationService {
21
    Task NotifyOrderCreatedAsync(Order order);
22
}
23

24
public class LocalNotificationService : INotificationService {
25
    public async Task NotifyOrderCreatedAsync(Order order) {
26
        await emailSender.SendAsync(...);
27
        await smsSender.SendAsync(...);
28
    }
29
}
30

31
public class RemoteNotificationService : INotificationService {
32
    private readonly HttpClient httpClient;
33

34
    public async Task NotifyOrderCreatedAsync(Order order) {
35
        // Call microservice
36
        await httpClient.PostAsync(
37
            "http://notification-service/notify",
38
            new StringContent(JsonSerializer.Serialize(new {
39
                order_id = order.Id,
40
                type = "order_created"
41
            }))
42
        );
43
    }
44
}
45

46
public class OrderService {
47
    private readonly INotificationService notificationService;
48

49
    public OrderService(INotificationService notificationService) {
50
        this.notificationService = notificationService;
51
    }
52

53
    public async Task<Order> CreateOrderAsync(string userId, List<Item> items) {
54
        User user = await db.Query<User>().Where(u => u.Id == userId).FirstAsync();
55
        Order order = new Order(userId, items);
56
        await db.AddAsync(order);
57

58
        // Use abstraction (doesn't know if local or remote!)
59
        await notificationService.NotifyOrderCreatedAsync(order);
60

61
        return order;
62
    }
63
}

Step 5: Data Migration Strategy

Challenge: Legacy and new service need the same data during transition!

Option A: Dual Writes

1
# In monolith during transition
2
def create_order(user_id, items):
3
    # Write to legacy DB
4
    order = Order(user_id=user_id, items=items)
5
    legacy_db.add(order)
6

7
    # ALSO write to new service
8
    try:
9
        httpx.post(
10
            "http://order-service/orders",
11
            json=order.to_dict()
12
        )
13
    except Exception as e:
14
        # Log error but don't fail
15
        # New service will eventually sync
16
        logger.error(f"Failed to sync order: {e}")
17

18
    return order

Pros: Simple Cons: Can get inconsistent if one write fails

Option B: Event-Based Sync

1
# Monolith publishes events
2
def create_order(user_id, items):
3
    order = Order(user_id=user_id, items=items)
4
    legacy_db.add(order)
5

6
    # Publish event
7
    event_bus.publish(OrderCreatedEvent(order))
8

9
    return order
10

11
# New service subscribes to events
12
@event_handler(OrderCreatedEvent)
13
def sync_order(event: OrderCreatedEvent):
14
    # New service builds its own view
15
    order = Order(
16
        id=event.order_id,
17
        user_id=event.user_id,
18
        ...
19
    )
20
    new_db.add(order)

Pros: Eventual consistency, reliable Cons: More complex

Option C: Change Data Capture (CDC)

Use tools like Debezium to capture database changes:

1
# Debezium connector config
2
{
3
  "name": "legacy-db-connector",
4
  "config": {
5
    "connector.class": "io.debezium.connector.postgresql.PostgresConnector",
6
    "database.hostname": "legacy-db",
7
    "database.dbname": "ecommerce",
8
    "table.include.list": "public.orders,public.users",
9
    "transforms": "route",
10
    "transforms.route.type": "org.apache.kafka.connect.transforms.RegexRouter",
11
    "transforms.route.regex": ".*",
12
    "transforms.route.replacement": "order-events"
13
  }
14
}

Pros: Zero code changes in legacy system Cons: Requires CDC infrastructure

Step 6: Gradual Rollout

Use feature flags to control traffic:

1
# Start with 5% traffic to new service
2
NOTIFICATION_SERVICE_PERCENTAGE = 5
3

4
# Week 1: Monitor metrics
5
NOTIFICATION_SERVICE_PERCENTAGE = 5
6

7
# Week 2: No issues, increase
8
NOTIFICATION_SERVICE_PERCENTAGE = 20
9

10
# Week 3: Looking good
11
NOTIFICATION_SERVICE_PERCENTAGE = 50
12

13
# Week 4: Almost there
14
NOTIFICATION_SERVICE_PERCENTAGE = 90
15

16
# Week 5: Full migration!
17
NOTIFICATION_SERVICE_PERCENTAGE = 100
18

19
# Week 6: Remove legacy code
20
# Delete old notification code from monolith

Step 7: Decommission Legacy Code

Once 100% migrated:

Verify no traffic to legacy endpoint

1
-- Check logs for any legacy calls
2
SELECT COUNT(*) FROM access_logs
3
WHERE endpoint = '/legacy/notifications'
4
AND timestamp > NOW() - INTERVAL '7 days';

Remove code from monolith

1
# Delete old notification code
2
# DELETE: monolith/models/notification.py
3
# DELETE: monolith/controllers/notification_controller.py

Drop legacy tables

1
-- Archive data first!
2
CREATE TABLE notifications_archive AS
3
SELECT * FROM notifications;
4

5
-- Then drop
6
DROP TABLE notifications;

Update documentation
- Update architecture diagrams
- Update API documentation
- Update team ownership

Migration Patterns and Strategies

1. Feature-Based Extraction

Extract complete features (vertical slices):

Extract complete features: Notification Service includes send email, send SMS, send push notification, query notification history, and manage notification preferences. Don’t extract incomplete features like email sender only—extract complete business capabilities.

2. Layer-Based Extraction

Extract by technical layer (less common):

1
Phase 1: Extract presentation layer → New API Gateway
2
Phase 2: Extract business logic    → New services
3
Phase 3: Extract data access       → New databases

Usually not recommended - features are better boundaries.

3. Branch by Abstraction

Create abstraction, switch implementation:

Branch by abstraction in four steps: direct call, notifier interface, local and remote notifiers side by side, then remote only

Benefits of Strangler Fig Pattern

Low Risk

No big-bang rewrite. If migration fails, roll back easily. Legacy system keeps working.

Incremental Value

Deliver value continuously. Each extracted service brings immediate benefits.

Learning Opportunity

Learn microservices gradually. Mistakes in first service don’t affect the whole system.

Business Continuity

No feature freeze. Continue delivering features while migrating.

Challenges and Pitfalls

1. The Never-Ending Migration

Problem: Migration takes too long, loses momentum

Solution:

Set clear deadlines for each service
Celebrate milestones
Measure progress (% of traffic migrated)
Dedicate resources

2. Data Consistency Issues

Problem: Legacy and new system out of sync

Solution:

Use event-driven architecture
Implement reconciliation jobs
Monitor data quality metrics

3. Increased Complexity During Transition

Problem: Running both systems is complex

Solution:

Good observability (tracing across both systems)
Clear ownership (team owns migration end-to-end)
Time-boxed migration (6-12 months max per service)

4. The Tangled Web

Problem: “Leaf service” turns out to have hidden dependencies

Solution:

Thorough dependency analysis before starting
Visualize dependency graph
Extract dependencies first

Real-World Case Studies

Soundcloud: Monolith to Microservices (2014-2018)

Starting Point:

Ruby on Rails monolith
3M+ users
Growing team (50+ engineers)

Strategy:

Identified bounded contexts (User, Track, Playlist)
Extracted services gradually over 4 years
Used event sourcing for data sync

Results:

Successfully migrated to 100+ microservices
Improved deployment frequency (5x)
Reduced time-to-market for features

Key Lesson:

“We didn’t try to do it all at once. We extracted services as we needed to scale or change them.” - Soundcloud Engineering

Netflix: The Long Migration (2008-2015)

Starting Point:

Monolithic DVD rental application
Database couldn’t scale

Strategy:

Started by extracting video streaming service
Gradually migrated over 7 years
Built extensive tooling for microservices

Results:

700+ microservices
Global scale (200M+ subscribers)
Industry leader in microservices practices

Key Lesson:

“The strangler pattern was essential. We couldn’t pause the business for a rewrite.” - Netflix Engineering

Amazon: The Forced Migration (2002-2006)

The Mandate:

“All teams will expose their data and functionality through service interfaces. No other form of communication allowed.” - Jeff Bezos, 2002

Strategy:

Top-down mandate
Each team migrated their module
Built AWS tools to support migration

Results:

Full SOA by 2006
Foundation for AWS
Enabled massive innovation

Tools and Techniques

1. Feature Flags

1
from unleash import UnleashClient
2

3
client = UnleashClient(url="http://unleash:4242")
4

5
def notify_user(order):
6
    if client.is_enabled("use_notification_service"):
7
        # Call new service
8
        notification_service.notify(order)
9
    else:
10
        # Use legacy code
11
        email_sender.send(order)

2. API Gateway for Routing

1
# Kong API Gateway configuration
2
routes:
3
  - name: notifications-new
4
    paths: ["/api/notifications"]
5
    service: notification-service
6
    plugins:
7
      - name: rate-limiting
8
      - name: request-transformer
9
        config:
10
          add:
11
            headers: ["X-Source:gateway"]
12

13
  - name: notifications-legacy
14
    paths: ["/api/notifications"]
15
    service: legacy-monolith
16
    plugins:
17
      - name: canary
18
        config:
19
          percentage: 10  # 10% to new service

3. Database Replication

1
-- Replicate legacy database to new service
2
CREATE PUBLICATION legacy_pub FOR TABLE orders, users;
3

4
-- New service subscribes
5
CREATE SUBSCRIPTION new_service_sub
6
CONNECTION 'host=legacy-db dbname=ecommerce'
7
PUBLICATION legacy_pub;

Key Takeaways

Don't Rewrite!

Big rewrites fail 70% of the time. Strangler Fig pattern migrates gradually and safely.

Start with Leaves

Extract services with few dependencies first. Learn from early migrations.

Dual-Run is Key

Run old and new systems in parallel. Route traffic gradually. Validate correctness.

Set Time Limits

Migrations can drag on forever. Set clear deadlines and celebrate milestones.

Monolithic Architecture - What you’re migrating from
Microservices Architecture - What you’re migrating to
Adapter Pattern - Creating abstraction layers
Facade Pattern - Proxy/gateway implementation
Event-Driven Architecture - Data synchronization

Strangler Fig Pattern

What is the Strangler Fig Pattern?

Real-World Scenario: The Big Rewrite Problem

How the Strangler Fig Pattern Works

Three Phases

Key Components

Step-by-Step Migration Strategy

Step 1: Identify Boundaries

Good Candidates for Extraction

Bad Candidates for Extraction

Step 2: Create Abstraction Layer

Step 3: Implement Facade/Proxy

Step 4: Extract Service (Build New)

Step 5: Data Migration Strategy

Option A: Dual Writes

Option B: Event-Based Sync

Option C: Change Data Capture (CDC)

Step 6: Gradual Rollout

Step 7: Decommission Legacy Code

Migration Patterns and Strategies

1. Feature-Based Extraction

2. Layer-Based Extraction

3. Branch by Abstraction

Benefits of Strangler Fig Pattern

Challenges and Pitfalls

1. The Never-Ending Migration

2. Data Consistency Issues

3. Increased Complexity During Transition

4. The Tangled Web

Real-World Case Studies

Soundcloud: Monolith to Microservices (2014-2018)

Netflix: The Long Migration (2008-2015)

Amazon: The Forced Migration (2002-2006)

Tools and Techniques

1. Feature Flags

2. API Gateway for Routing

3. Database Replication

Key Takeaways

Related Topics

Further Reading