Design & Implementation: Choosing a Sound Structure and a Safe Way to Build It
Learn what the Design & Implementation patterns cover, how Strangler Fig and Sidecar solve structural problems, and how to weigh their costs before you use them.
In short
Design and Implementation patterns cover how a system is structured and built, using shapes like Strangler Fig and Sidecar that each have costs.
10 min readFree
What You Will Learn
Design & Implementation is one group of cloud design patterns. In this course, the name covers patterns about how a system is structured and built: how to split it into parts, how to move from an old design to a new one step by step, and how to attach helper components. It is not about making one slow feature faster. That work belongs to other lessons.
By the end of this lesson, you should be able to name the problem a structural pattern solves, follow one worked example, and explain when a pattern is not worth using.
Key words
- Design & Implementation
- In this course, the group of patterns about how a system is structured and built.
- Pattern
- A named, tested answer to a problem that shows up again and again in many projects.
- Structure
- How a system's parts are divided up and how those parts connect.
- Legacy system
- An older system that still runs the business and is hard to change.
- Monolith
- One large application where all features are packed into a single unit that is deployed together.
- Façade
- A front-door component that receives each request and passes it to the right place. Some people call it a proxy or a routing layer.
- Sidecar
- A helper process or container that runs beside a service and handles a side task, such as logging.
- Trade-off
- A cost you accept in return for a benefit.
Why Does Structure Decide Future Change?
A system is built from code and components. The way those pieces are arranged decides how the system is built, changed, deployed and maintained. Azure's guidance for this group names consistency, maintainability and reusability as the goals to aim for. It also warns that decisions made at this stage strongly affect both the quality of the result and its total cost.
A sound structure keeps each piece focused on one responsibility. When a part has one clear job, a change to that job stays inside that part. The three cards below show why this matters in daily work.
Building
Parts with clear edges let several people work at the same time without editing the same files.
Changing
When a change stays inside one component, the work and the testing stay small, so later changes cost less.
Running
Each part can be updated, restarted or watched on its own, which makes deployment and upkeep simpler.
Why Do Patterns Solve Problems That Repeat?
A pattern does not give you finished code. It names a problem, describes a shape that solves it, and lists what that shape costs. Azure's catalog advises you to start from the problem in front of you, not from the technology you would like to try. A pattern is a good fit only when its problem matches yours and you can accept its trade-offs.
The Azure Architecture Center sorts its patterns into groups, and Design & Implementation is one of them. The ACM book on cloud design patterns lists the same group among its categories. These three cards are the patterns this lesson introduces. Each one has its own lesson later.
Strangler Fig
Replaces an old system one piece at a time. A routing layer decides which requests go to the old code and which go to new services.
Sidecar
Places a helper, such as logging or network proxying, beside a service so that the service's own code does not have to change.
Anti-Corruption Layer
Acts as a translator between a new system and an old one, so the old system's rules do not leak into the new design.
The next two sub-topics give a short first look at the first two. Full walkthroughs, and the Anti-Corruption Layer, come in their own lessons later.
What Is Strangler Fig in Brief?
Strangler Fig in brief. The name comes from Martin Fowler, who took it from strangler fig plants. These vines grow around a host tree and eventually take its place. In software, a façade sits in front of the old system. At first it sends most traffic to the old code. Then, as new services are built and checked, it sends more traffic to them. When nothing depends on the old system, it is switched off. The façade is then removed, so clients talk to the new system directly.
What Is Sidecar in Brief?
Sidecar in brief. The name comes from the small seat attached to a motorcycle. A sidecar is a separate process or container that runs next to an application and shares its life cycle, so both start and stop together. It handles side tasks such as logging, monitoring, configuration and network proxying. Because it runs apart from the application, it can be written in a different language. Each copy adds some resource use and a little delay when the two talk.
Worked Example: A Store Moves Off Its Old App
Picture an online store. Its checkout and its order tracking both run inside one old monolith. The team wants a new order tracking screen, but a full rewrite is too risky, and the store cannot go offline. The team uses the Strangler Fig pattern, and it runs a logging sidecar beside the new service.
- 1
Put a routing layer in front
Place a façade between shoppers and the old app. At first, every request still reaches the old app, so shoppers see no change.
- 2
Build one new piece
Write a new order tracking service. Only this screen is new. Checkout stays in the old app for now.
- 3
Route one path to the new service
Tell the façade to send any path that starts with the tracking address to the new service. Every other path still goes to the old app.
- 4
Attach a logging sidecar
Run a logging helper beside the new service. It records what passes through, and the service's own code stays as it was written.
- 5
Repeat, then retire
Move the next screen later, one at a time. When nothing depends on the old app, switch it off and remove the façade.
The routing rule is the heart of this example. The small program below shows the same decision in code. It is a toy, not the store's real router, but it makes the idea visible.
def route(path):
if path.startswith('/orders/track'):
return 'new-tracking-service'
return 'legacy-app'
for p in ['/orders/track/123', '/checkout', '/orders/track']:
print(p, '->', route(p))Output
/orders/track/123 -> new-tracking-service /checkout -> legacy-app /orders/track -> new-tracking-service
Notice what did not change. Shoppers still use the same web address. Checkout code was never touched. Each later move is small, and each one can be undone by sending the path back to the old app.
What Does Every Structural Choice Cost?
No pattern is free. Each one adds something to build, run and learn. Before you adopt one, list what it costs you. The three cards below are the usual costs in this group.
Added complexity
Two systems now run side by side. The team must understand both of them, plus the routing layer between them.
Extra parts
A façade, a sidecar and a new service are more pieces to deploy, watch and pay for.
Migration risk
Clients must know which version holds each feature, and both systems may need the same data at once. The team must plan how those copies stay in step.
Azure's Strangler Fig guidance also warns that the routing layer must keep up with the migration and must not become a single point of failure or a bottleneck. Treat the façade as temporary scaffolding. Its benefit is lower risk, and its cost is extra infrastructure while the move is under way.
When a Pattern Is Not Worth Using
When not worth using. Azure's guidance names clear cases where the Strangler Fig pattern is a poor fit. Requests to the old system cannot be intercepted. The team cannot change the old code or its database. The system is small and a full replacement is simple. Or the old system must be shut down quickly. Sidecars also have limits. They add delay, so they suit poorly any part that talks to its neighbour very often. They are costly for a small app, and they are not needed when the platform already offers the feature.
Tip
Ask one plain question before you add any structural part: what exact problem does this solve here? If you cannot name the problem in one sentence, you probably do not need the pattern yet.
Three Questions Before You Adopt a Pattern
- 1
What problem is it solving?
State the pain in one sentence, such as 'a rewrite would need a long shutdown'. If the sentence is vague, stop and clarify it first.
- 2
What does it add?
List the new parts, the new links between them, and the new places where things can fail.
- 3
Is a simpler option enough?
Compare with a small change to the current design or a feature the platform already provides. Choose the simplest design that meets the real need.
Quick Check
Try these three short scenarios. Each one needs the ideas from this lesson.
Quick check
A team wants to replace a ten-year-old monolith. It cannot afford downtime or a risky rewrite of everything at once. Which approach fits, and what should sit in front of the old system?
Quick check
A company runs twelve services written in four languages. Every service needs the same request logging, and the team does not want to edit the code of each service. What is the best fit?
Quick check
A small internal tool has three screens and can be replaced in a weekend. A colleague proposes a full façade and a migration plan. What is the best advice?
Key Takeaways
Design & Implementation patterns are about structure: how parts are split, how systems are moved step by step, and how helpers are attached. Strangler Fig replaces an old system piece by piece behind a routing layer. Sidecar adds a helper beside a service without changing the service's code. Both give real benefits, and both bring costs in complexity, extra parts and migration risk. Always ask which problem a pattern solves, and whether a simpler design would do.
Sources
- Azure Architecture Center: Cloud design patterns (index and selection advice)
- Azure Architecture Center: Strangler Fig pattern
- Azure Architecture Center: Sidecar pattern
- Azure Architecture Center: Design patterns for microservices
- Wikipedia: Strangler fig pattern
- Cloud Design Patterns: Prescriptive Architecture Guidance for Cloud Applications (ACM Digital Library listing)
- Introduction to Cloud Design Patterns, Nachiket Vaidya (IJERT)
Last updated on 18 November 2026
Related lessons
- Design systemsDesign Language: The Look, Feel, and Voice Behind a Design System
- Design systemsDesign Principles: Short Statements That Settle Design Trade-Offs
- Design systemsDefining Design Tokens: Named Design Decisions Shared by Designers and Builders
- Design systemsDesign Editor: Set Up One Shared Design System File Your Team Can Trust
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.