Development Skill
Angular Migration
Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and…
$15
Microservices Patterns
Design microservices architectures with service boundaries, event-driven communication, and…
A design guide for microservices architectures covering service boundaries, inter-service communication, distributed data, and resilience. It shows how to decompose monoliths, choose synchronous versus event-driven communication, and add circuit breakers, sagas, and bulkheads that keep distributed systems stable under failure.
$15 one-time
Add to a kit → Prices include 20% VAT. · Forged on real agency work · one-time, no lock-in
- Type Skill
- Category Development
- Delivery Email · instant
- License One-time
Inside the run · no black box
See the actual work before you buy it.
Most microservice failures are boundary failures. So this skill starts at the boundaries: one domain per service, one database per owner, and resilience wired in as a default before traffic arrives.
- Draws bounded contexts before any code: each service owns one domain concept and its own database, no shared tables, shared models capped at 2-3 DTOs, and a context map marking who is upstream and who is downstream.
- Decides the communication mode per interaction: synchronous REST/gRPC gets a hardened client with timeouts, connection limits and exponential-backoff retries; anything that can be async becomes an event on Kafka, partitioned by aggregate id so events for one order stay ordered.
- Makes every event consumer idempotent and gives it a dead letter queue: the same event arriving twice produces the same result, and three failed retries route the message to DLQ for manual inspection instead of silent loss.
- Wires distributed transactions as sagas: each step (create order, reserve inventory, process payment, confirm) carries a compensating action, and on failure the completed steps roll back in reverse order. Four or more steps means orchestration, two or three can stay choreography.
- Installs resilience as a default, not an option: a circuit breaker on every service-to-service call (5 failures open the circuit for 30 seconds, then half-open probing) plus bulkhead isolation so one slow dependency cannot drain every pool.
- Aggregates at the API gateway with partial-failure handling: parallel fan-out to services, and when one of them is down the response still ships what succeeded instead of failing the whole page.
One power source. 6 lines out.
microservices-patterns · core
core active · 6 lines
- ✓ decomposing a monolith i…
Decomposing a monolith into well-bounded services
- ✓ designing service bounda…
Designing service boundaries and API contracts
- ✓ choosing between rest, g…
Choosing between REST, gRPC, and event-driven communication
- ✓ managing distributed tra…
Managing distributed transactions with saga compensation
- ✓ adding resilience with c…
Adding resilience with circuit breakers and bulkheads
- ✓ building an api gateway
Building an API gateway that aggregates services and handles partial failure
Yours to keep.
Drag time forward. Watch what stays.
Forever
That's what owning means.
The rented stack
ai writing tool: subscription
expired · access lostanalytics suite: subscription
expired · access lostdesign platform: subscription
expired · access lost(nothing left)
Your forge
-
Avoid the distributed-monolith trap with clear, business-aligned boundaries
license: perpetual -
Keep failures contained so one slow service doesn't cascade across the system
license: perpetual -
Maintain data consistency across services with proper saga compensation
license: perpetual -
Migrate from monolith incrementally with no risky big-bang rewrite
license: perpetual
subscriptions expire · deeds don't
Everything in the box.
Pick a piece up. Watch it work.
Service decomposition strategies by business capability and subdomain
6 parts · one working system · ships instantly by email
This wasn't forged for everyone.
- Not for you if you'd rather rent a tool than own one.
- Not for you if you want someone else to run your stack.
- Not for you if you're happy guessing.
Backend architects and engineers building distributed systems or decomposing monoliths into microservices.
then this was forged for you.Works with
Universal by design: these run in any AI. Delivered in the open Agent Skills + MCP format (native in Claude); ChatGPT, Gemini, Cursor and Copilot adapt the same files their own way.
- Claude Native format
- ChatGPT Adapts via open standards
- Gemini Adapts via open standards
- Cursor Adapts via open standards
- Copilot Adapts via open standards
Catch what's on your mind.
the air is clear. nothing between you and the forge.
catch a spark: the forge will answer
-
We're still on a monolith. Is this useful before we've split anything?
That is the starting point it assumes: decomposition strategies by business capability and subdomain, plus the strangler-fig pattern for migrating incrementally instead of a big-bang rewrite. You can do the boundary work while the monolith is still running.
-
How does it keep data consistent without distributed transactions?
Through a full saga orchestration implementation with compensating actions: each step has a defined rollback, so a failure midway unwinds cleanly instead of leaving half-written state. Circuit breakers and bulkheads keep the failure itself from cascading.
-
Does it choose my infrastructure, like Kubernetes or a message broker?
No. It is an architecture patterns guide covering boundaries, communication choices, and resilience, with Kafka shown as the event-driven example. Cluster setup, broker operations, and deployment tooling are outside its scope.
-
How is it delivered?
By email right after purchase: ready to run, downloaded instantly, no setup wait.
-
One-time or subscription?
A one-time purchase; no subscription or hidden fees. VAT (20%) is included.
-
Can I get a refund?
As a digital product, it can’t be refunded once downloaded. That’s why we show exactly what’s inside and who it’s for, right here.