Skip to content

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.

Six parts, read in order. Each builds on the ones before it.

📍 Start HereI Understand the ProblemII Find Better BoundariesIII Pull Apart SafelyIV Change CollaborationV Operate the PlatformVI Next Growth Phase
○ planned● current✓ published
Part IUnderstanding the ProblemUnderstand what actually deserves to change before choosing architecture.
Part IIFinding Better BoundariesUnderstand the business and code boundaries before decomposing anything.
  • ✓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?
Part IIIPulling the System Apart SafelyTurn the boundaries and seams into a real, incremental extraction, confronting what the diagrams do not solve: distributed communication, data ownership, coexistence, and safe cutover. Implementation examples appear here to demonstrate the reasoning, not as a coding tutorial.
  • ✓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.
Part IVChanging How Systems CollaborateHow independently owned domains collaborate, including the messy realities of asynchronous messaging.
  • ○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?
Part VOperating the New PlatformDecomposition is not finished when the code is split: the platform must also be observable, resilient, independently deployable, and able to evolve contracts safely.
  • ○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?
Part VIPreparing for the Next Growth PhaseShow the business payoff of the modernization, and the new pressures created by success.
  • ○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?

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.

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.