Chapter 2: FTGO: A case study in moving from one kind of development hell to another
The chapter introduces FTGO’s move from an outgrown monolith to microservices as a case where a suitable architectural choice still went badly wrong.
After this chapter you will be able to
- Architecture fit versus success. Explain why microservices were a reasonable fit for FTGO but did not guarantee a successful migration.
- FTGO monolith’s changing fortunes. Describe how FTGO’s first application supported early growth but later became difficult to develop as the business, application, and engineering organization expanded.
- FTGO business logic and adapters. Describe how FTGO’s business logic is organized into modules and surrounded by adapters, distinguishing adapters that handle incoming requests from those that access external systems.
- Logical modules in one deployment. Explain why FTGO is a monolith despite its modular design, and state how that choice affected development when the application was small.
- Initial development and change benefits. Explain why FTGO’s monolith was initially simple to develop and made radical changes relatively easy.
- Initial testing deployment and scaling. Describe how FTGO initially tested, deployed, and scaled its monolith, and state what happened to those activities over time.
- Growth and tangled domain. Explain how FTGO’s growing code base and engineering organization exposed poor domain modularity, making changes increasingly difficult.
- Commit to production bottlenecks. Trace why completed FTGO work took so long to reach production despite squads and two-week sprints.
- Production reliability and diagnosis. Explain why FTGO experienced outages and why finding their causes was difficult.
- FTGO migration decision. Explain why Mary decided FTGO should migrate from a monolith to microservices: she concluded that its application and engineering organization had outgrown the monolithic architecture.
- FTGO microservices adoption approaches. Describe how FTGO adopted microservices by rewriting existing applications from scratch and taking a microservices-first approach to new applications. State that the rewrites took a few years, especially for the large main application, but succeeded.
- Inconsistent V2 service boundaries. Explain that FTGO’s teams used different ideas of what a service should be, producing services of different sizes organized around either business domains or technical capabilities.
- Simpler services and team autonomy. Explain how smaller services made FTGO’s components easier to work with and allowed teams to develop and deploy independently.
- Technology and deployment flexibility. Describe how separate services let FTGO use and upgrade different technology stacks and deploy modules with distinctive requirements separately.
- Barriers to frequent deployment. Explain why FTGO still deployed infrequently despite moving to microservices, and how infrequent, large releases made production outages harder to diagnose.
- Sources of design-time coupling. Describe how both the intentional Order Service–Order Data Service split and the evolving Order Service–Restaurant Service model made changes span services, and explain the effect on development.
- Cross-service data inconsistency. Explain how FTGO’s fine-grained architecture made requests that update multiple services complex and led to hard-to-find data inconsistency bugs.
- Network and availability costs. Distinguish the performance problem caused by network traffic from the failure problem caused by runtime dependence among services.
- Migration and adoption mistakes. Explain the costs of FTGO’s big-bang rewrite and why migrating every existing application or starting every new application with microservices brought little value.
What it builds on
- The fast flow success triangle = DevOps + Team Topologies + Architecture (chapter 1) · The fast flow success triangle named as a concept FTGO ignored.
- The Monolithic architecture can enable fast flow (chapter 1) · The idea that a monolithic architecture can enable fast flow.
- The microservice architecture: a definition (chapter 1) · The expectation that microservices should be loosely coupled.
- Building an application from scratch: typically a monolith-first approach (chapter 1) · The question of when a new application should begin with microservices.
- Refactoring a monolith to the microservice architecture (chapter 1) · The question of when to refactor an existing monolith.
Section by section
Introduction
The chapter introduces FTGO’s move from an outgrown monolith to microservices as a case where a suitable architectural choice still went badly wrong.
- Architecture fit versus success: Explain why microservices were a reasonable fit for FTGO but did not guarantee a successful migration.
Why it matters: It separates choosing a suitable architecture from adopting it successfully.
Key terms: FTGO, monolithic architecture, microservice architecture, fast flow success triangle
2.1 FTGO architecture V1: The eventual descent into monolithic hell
This section introduces how FTGO’s initially successful monolith became a large, poorly structured application that slowed development as the company grew.
- FTGO monolith’s changing fortunes: Describe how FTGO’s first application supported early growth but later became difficult to develop as the business, application, and engineering organization expanded.
Why it matters: FTGO’s experience shows that an architecture can serve a company well at first yet become troublesome as the company grows.
Key terms: monolith, Java Web Application Archive (WAR) file, Big Ball of Mud
2.1.1 The architecture of the FTGO application
The section describes FTGO’s hexagonal application structure and explains why its logically modular design was initially deployed as a monolith.
- FTGO business logic and adapters: Describe how FTGO’s business logic is organized into modules and surrounded by adapters, distinguishing adapters that handle incoming requests from those that access external systems.
Why it matters: This distinction explains how FTGO separates its domain work from user interfaces and external systems. - Logical modules in one deployment: Explain why FTGO is a monolith despite its modular design, and state how that choice affected development when the application was small.
Why it matters: Logical modularity and monolithic packaging can coexist, and FTGO initially benefited from that combination.
Key terms: hexagonal architecture, business logic, modules, inbound adapters, outbound adapters, logically modular architecture, single WAR file, monolithic architecture
2.1.2 Why the monolithic architecture worked well initially
This section explains why FTGO’s monolithic architecture was initially convenient, while noting that its advantages eroded over time.
- Initial development and change benefits: Explain why FTGO’s monolith was initially simple to develop and made radical changes relatively easy.
Why it matters: These advantages explain why the monolith worked well for FTGO at first. - Initial testing deployment and scaling: Describe how FTGO initially tested, deployed, and scaled its monolith, and state what happened to those activities over time.
Why it matters: The contrast between early convenience and later difficulty is central to FTGO’s experience with the monolith.
Key terms: monolithic architecture, radical changes, database schema, end-to-end tests, REST API, Selenium, WAR file, Tomcat, load balancer
2.1.3 Living in what they thought was monolithic hell
This section explains why FTGO’s growing monolith made development, deployment, reliability, scaling, and technology upgrades increasingly difficult.
- Growth and tangled domain: Explain how FTGO’s growing code base and engineering organization exposed poor domain modularity, making changes increasingly difficult.
Why it matters: An architecture that looks modular does not make change easy if the code underneath is tangled. - Slow development feedback loop: Describe why routine editing and testing became slow for FTGO developers.
Why it matters: Slow local feedback makes even ordinary development work take longer. - Commit to production bottlenecks: Trace why completed FTGO work took so long to reach production despite squads and two-week sprints.
Why it matters: Short sprints do not produce fast delivery when integration, testing, and stabilization remain slow. - Production reliability and diagnosis: Explain why FTGO experienced outages and why finding their causes was difficult.
Why it matters: Release frequency, testability, and fault isolation all affected FTGO’s production reliability. - Conflicting module resource needs: Explain why scaling the monolith required a server-configuration compromise.
Why it matters: A single deployment configuration can be a poor fit when parts of an application need different resources. - Monolith technology stack constraints: Describe why FTGO struggled to upgrade its technology stack and experiment with other languages.
Why it matters: Application-wide technology decisions can make both maintenance and experimentation costly.
Key terms: hexagonal architecture, domain, big ball of mud, edit-build-run-test loop, IDE, feature branches, Continuous Integration (CI) server, unreleasable state, testing cycle, testability
2.2 FTGO architecture V2: Fine-grained microservices everywhere - a different kind of hell
Introduces why FTGO decided to replace its monolith with microservices, setting up the account of its V2 architecture.
- FTGO migration decision: Explain why Mary decided FTGO should migrate from a monolith to microservices: she concluded that its application and engineering organization had outgrown the monolithic architecture.
Why it matters: Mary's decision explains why FTGO undertook the move to its V2 architecture.
Key terms: monolithic hell, monolithic architecture, microservice architecture
2.2.1 How FTGO adopted the microservice architecture
This section describes FTGO’s two approaches to adopting microservices and notes how long its application rewrites took.
- FTGO microservices adoption approaches: Describe how FTGO adopted microservices by rewriting existing applications from scratch and taking a microservices-first approach to new applications. State that the rewrites took a few years, especially for the large main application, but succeeded.
Why it matters: This distinction explains how FTGO arrived at its V2 applications rather than treating its adoption of microservices as a single project.
Key terms: microservice architecture, microservices-first approach, rewrites
2.2.2 The V2 architecture of the main FTGO application
This section describes FTGO’s V2 application as a collection of services whose boundaries, sizes, and data ownership varied across teams.
- Inconsistent V2 service boundaries: Explain that FTGO’s teams used different ideas of what a service should be, producing services of different sizes organized around either business domains or technical capabilities.
Why it matters: This variation is the defining feature of the V2 architecture described here. - Order and Courier data separation: Describe the Order Management team’s Order and Courier Services and explain that each stored its data in a separate Data Service rather than its own database.
Why it matters: These services give a concrete example of how one V2 team divided responsibilities and data. - Consumer service fragmentation: Contrast Consumer Management’s collection of tiny, individually database-owning services with the Order and Courier Services’ separate Data Services.
Why it matters: The contrast makes the teams’ differing approaches to service boundaries and data ownership tangible.
Key terms: business domains, technical capabilities, services, Order Service, Courier Service, Order Data Service, Courier Data Service, Order Management team, Consumer Management, Consumer Profile Service
2.2.3 What worked well with the V2 architecture
This section identifies the benefits FTGO gained from its V2 architecture while noting that the architecture also brought severe problems.
- Simpler services and team autonomy: Explain how smaller services made FTGO’s components easier to work with and allowed teams to develop and deploy independently.
Why it matters: These benefits explain why the V2 architecture initially improved day-to-day development. - Technology and deployment flexibility: Describe how separate services let FTGO use and upgrade different technology stacks and deploy modules with distinctive requirements separately.
Why it matters: Service boundaries gave FTGO flexibility in both technology choices and how it deployed modules with special requirements.
Key terms: simpler components, team autonomy, services, technology stacks, technology stack upgrades, segregate modules by characteristics
2.2.4 What went wrong with their microservice architecture
FTGO’s V2 case shows how fine-grained services, neglected deployment and coupling practices, and poorly chosen migration strategies undermined the benefits the company expected from microservices.
- Barriers to frequent deployment: Explain why FTGO still deployed infrequently despite moving to microservices, and how infrequent, large releases made production outages harder to diagnose.
Why it matters: Splitting an application into services does not speed delivery if its testing and release practices still hold changes together. - Sources of design-time coupling: Describe how both the intentional Order Service–Order Data Service split and the evolving Order Service–Restaurant Service model made changes span services, and explain the effect on development.
Why it matters: Service boundaries that force changes to travel together can erase the development-speed benefit FTGO sought. - Cross-service data inconsistency: Explain how FTGO’s fine-grained architecture made requests that update multiple services complex and led to hard-to-find data inconsistency bugs.
Why it matters: A change to data across many services can be difficult to implement and debug correctly. - Network and availability costs: Distinguish the performance problem caused by network traffic from the failure problem caused by runtime dependence among services.
Why it matters: A request can suffer both high latency and greater failure risk when it depends on too many service calls. - Inconsistent service plumbing: Explain why FTGO still found technology-stack upgrades difficult even though it could upgrade services one at a time.
Why it matters: Independent service upgrades offered less benefit when every service’s infrastructure code required different work. - Migration and adoption mistakes: Explain the costs of FTGO’s big-bang rewrite and why migrating every existing application or starting every new application with microservices brought little value.
Why it matters: FTGO’s experience shows that both how an organization migrates and which applications it migrates affect whether microservices deliver value.
Key terms: independent deployability, QA team, end-to-end tests, manual testing, design-time coupling, data services, Order Data Service, MenuItem, OrderLineItem, API evolution
2.3 Summary
Where this is used later
- Introduction to the modular monolith (chapter 6) · Motivates the discussion of a modular monolith.
- Testable using fast running tests (chapter 5) · Connects slow feedback to the need for fast-running tests.
- Testability: ease and speed of verifying releasability (chapter 5) · Motivates the importance of verifying changes quickly.
- Deployability: ease, speed and reliability of deployments (chapter 5) · Motivates the need for easier, faster deployments.
- Observability: ease of understanding an application’s runtime behavior (chapter 5) · Develops the concern of understanding failures in production.
- Other drawbacks of monolithic architecture (chapter 6) · Places this scaling difficulty among drawbacks of a monolithic architecture.
- Evolvability: ease and speed of changing the technology stack (chapter 5) · Develops evolvability as the ease of changing a technology stack.
- Enables fast, sustainable flow (chapter 7) · Develops the connection between service independence and fast, sustainable flow.
Concepts explained in this chapter
- monolithic architectureAn architecture in which an application is built and deployed as a single unit.
- microservices-first approachAn application-development strategy that begins by decomposing or building applications as microservices rather than first considering a monolithic design.
- fine-grained architectureAn architecture that divides application functionality into many small components or services, often requiring numerous inter-component interactions.
- data inconsistencyA condition in which representations of related data differ across services or components that should agree.
- data serviceA service whose primary responsibility is providing other application services with access to data.
- technology stack upgradeA technology stack upgrade is a change that updates the programming languages, libraries, frameworks, platforms, or tools used by an application component.
- technology stackThe combination of programming languages, runtimes, frameworks, libraries, and supporting technologies used to build and run an application or service.
- continuous deploymentContinuous deployment is the practice of automatically deploying every production-ready software change to production.
- fault isolationFault isolation is the ability to contain a component failure so that it does not bring down unrelated components.
- scalabilityThe capacity of a system to handle increasing workload by adding or adjusting resources while maintaining acceptable behavior.
- microservice architectureAn architectural style that structures an application as a collection of independently deployable services aligned with business capabilities.
- adapterA software component that connects application logic to an external interface or system by translating between their interfaces.
- business logicBusiness logic consists of the rules and computations that implement an application's domain behavior.
- driven adapterAn adapter that enables application business logic to access external systems or services.
- hexagonal architectureHexagonal architecture is an architectural pattern that isolates application and domain logic from external systems through ports and adapters.
- inbound adapterAn adapter that receives external requests and invokes application business logic.
- DevOpsA set of practices and cultural principles that integrates software development and operations to improve the flow and reliability of software delivery.
- fast flow success triangleThe fast flow success triangle is a model relating DevOps, Team Topologies, and enabling architecture as the three elements required for fast flow.
- runtime couplingA strong runtime dependency in which one component's failure or unavailability prevents another from completing its operation.
- team topologiesTeam Topologies is an organizational design framework for structuring teams and their interactions to optimize software delivery.
- tight couplingA relationship in which software elements have substantial dependencies on one another.
- autonomyTeam autonomy is a team property in which the team can perform its work with minimal dependence on coordination, hand-offs, or waiting on other teams.
- serviceA software component that provides a cohesive set of capabilities within an application.
- API evolutionAPI evolution is the controlled modification of an API contract while managing compatibility with its existing consumers.
- contractAn interface that defines how software components interact and access one another's functionality.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
