The Journey
ZibiWorks is a continuing architecture story. Each installment introduces a new business or technical pressure, explores the tradeoffs, and makes the next decision visible.
This page is the roadmap for that story. It shows where the series is going before you start the numbered installments, so you can see the shape of the whole thing and find your place in it.
The questions are planned. The architecture is not.
Section titled “The questions are planned. The architecture is not.”Planned
The questions ZibiWorks works through, and the order they tend to arrive in. We know the pressures the company will face.
Open
The answers. Microservices, events, CQRS, SaaS, and the rest are possible outcomes, not decisions already made. Each is earned by a specific pressure, or not at all.
This is a series roadmap, not an architecture roadmap. It describes the questions and the pressures. The installments work out the answers.
The path
Section titled “The path”Six parts, read in order. Each builds on the ones before it.
The installments
Section titled “The installments”- ✓What's Driving Change?What problem is ZibiWorks actually trying to solve?
- ✓Move It or Fix It First?Should ZibiWorks modernize before moving infrastructure?
- ✓Rewrite vs. EvolveShould ZibiWorks replace the monolith or change it incrementally?
- ✓Boundaries and MeaningHow do we discover the business boundaries before separating the software?
- ✓The First SeamNow that we understand the boundaries, where can we safely make the first cut?
- ✓Domain or Utility?What should be shared across domains, and when does shared code recreate coupling?
- ✓Who Owns the Data?How do we transfer data ownership from a monolith to a new service without disrupting existing business operations?
- ✓Choosing the Compatibility StrategyHow current does the legacy compatibility projection need to be, and how should ZibiWorks keep it that way without coupling the monolith to Fulfillment's internals?
- ○Building the Compatibility BridgeHow is the chosen strategy built, operated, and removed: initial load, authority transfer, reconciliation, fallback, and retirement?
- ○Implementing the First SeamThe seam exists as a decision. What does acting on it inside the monolith actually require, and how do we prove we have changed behavior nowhere yet?
- ○Crossing the BoundaryWhat changes when a local call becomes a remote one, and which of those failure modes force architectural decisions rather than just code?May grow to cover: synchronous versus asynchronous communication, service contracts, timeouts, retries, partial failure, and idempotency.
- ○Cutting Over Without Burning BridgesHow do we shift traffic from legacy to extracted Fulfillment safely, and how far does rollback actually reach once data has moved?May grow to cover: incremental cutover, Strangler routing, validation and observability, and rollback limitations. Data-level fallback and removing the migration scaffolding are covered in Building the Compatibility Bridge.
- ○The Front DoorHow should old and new capabilities coexist behind a stable entry point?
- ○One Backend, Different ExperiencesShould every user experience consume the same backend shape?
- ○Untangling the PartnersHow do the domain-and-utility decisions from Part II become working integrations: translation, runtime isolation, failure handling, and legacy coexistence?Builds on Domain or Utility? (Part II), which decides where the shipping integration belongs; this stop is where that decision becomes a running anti-corruption layer. An ACL need not be a separately deployed service.
- ○When Synchronous Stops WorkingWhich workflows really require an immediate response?
- ○Events Are FactsWhat should become an event?
- ○What If the Event Arrives Twice?What does reliable asynchronous collaboration require in the real world?May grow to cover: at-least-once delivery, duplicate messages, idempotency, ordering, retries, poison messages, dead-letter handling, outbox patterns, replay, consumer recovery, and eventual consistency.
- ○Reading Without OwningHow do we build views across domains without recreating the shared database?
- ○Orchestration or Choreography?Who coordinates a business process that crosses domain boundaries?
- ○Can We See What Is Happening?How do we operate a system once requests cross multiple components?
- ○What Happens When Dependencies Fail?How should the platform behave when something it depends on is slow or unavailable?
- ○Can We Deploy This Independently?What has to change before architectural boundaries become real deployment boundaries?May grow to cover: independent deployment, CI/CD boundaries, release coordination, backward compatibility, rollout and rollback, feature flags, and progressive delivery.
- ○When Contracts ChangeHow do independently evolving systems change APIs and events without breaking one another?May grow to cover: API compatibility, event contract evolution, versioning, consumer compatibility, schema evolution, and deployment skew.
- ○Resilience or Recovery?What failures do we design through, and what failures do we recover from?
- ○How Portable Should We Be?How much cloud-specific capability should ZibiWorks embrace?
- ○What Did We Buy With All This?What business capabilities became easier because of the modernization?
- ○From Product to PlatformWhat happens when capabilities originally built for ZibiWorks itself become useful to partners or other consumers?
- ○One Company, Many Customers?What new architectural pressures appear if ZibiWorks begins moving toward SaaS or multitenancy?
- ○The Next ZibiWorksWhat new pressures appear now that the company is ready to grow again?
A living roadmap
Section titled “A living roadmap”The ZibiWorks journey is a plan, not a contract. Like the modernization effort we’re exploring, the series evolves as we learn more.
We have a direction and a set of architectural challenges we intend to address, but we’re not committing to every decision or installment before we’ve explored the problems. Some topics may need more attention than originally anticipated. Others may combine, change order, or lead us somewhere unexpected.
That’s intentional. Architecture is an iterative process of discovery, where business constraints inform technical decisions, and those decisions reveal new questions for the business.
We’re approaching the series the same way we’d approach the modernization itself: with a roadmap, a willingness to adapt, and an understanding that the value is in the decisions we make along the way, not in following the original plan.
Start reading
Section titled “Start reading”The story begins after the two orientation pages: the business and the platform it runs on today. From there, Part I opens the first real decision.