Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Building Microservices

Building Microservices

Designing Fine-Grained Systems
Build independently deployable services without letting distributed complexity overwhelm your teams.
by Sam Newman 2014 473 pages
4.22
5k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Choose microservices for independent change, not because small services sound modern

The real promise is autonomy. Microservices are small services, each with its own lifecycle, that cooperate over a network. Their value is not smallness for its own sake. A team can change and deploy one service without coordinating a release of the whole system, and can choose technology suited to that service’s work.

The bill comes due. Separate services bring network failures, more deployments, and harder testing and monitoring. Gilt, an online retailer, began with a monolithic Rails application and eventually grew to more than 450 services to handle changing load. That scale reflects a particular company’s needs, not a target for every organization. A well-structured monolith may be a better starting point when teams cannot yet operate distributed systems reliably.

Analysis

The key distinction is between architectural freedom and architectural fashion. Independent deployment is valuable only when a team can actually deploy, observe, and support its service without waiting on a central bottleneck. This resembles a broader principle in organizational design: decentralization works when local units have both authority and the information needed to use it well. A service boundary without operational capability merely relocates complexity. The book’s case for microservices is strongest as a conditional argument: earn the added complexity by removing a real constraint on change.

Draw service boundaries around business capabilities, not database tables

Start with the work. A bounded context is a domain area with a defined responsibility and an explicit boundary around the concepts it owns. At MusicCorp, a warehouse handles stock and fulfillment, while finance handles accounts and reporting. Finance may need stock information, but it does not need the warehouse’s internal details, such as where an item sits on a shelf. The service should expose the information another capability needs, not its entire internal model.

Let the domain teach you. Ask what a context does before asking what data it stores. Warehouse work might split into inventory, receiving, and fulfillment, but only when the business or team structure supports those distinctions. The SnapCI team initially divided services too early, found that its domain boundaries were wrong, merged them, and separated them again after its understanding matured.

Analysis

This approach treats software boundaries as claims about responsibility, not merely as code organization. That is powerful because organizational language often reveals where decisions and change actually belong. It also cautions against mistaking nouns in a database for natural services: one table can contain several concepts, and one concept can require several processes. Boundaries remain hypotheses, however. Domain experts may disagree, and business responsibilities can shift. The practical test is whether a proposed boundary reduces the number of teams and services that must change together.

Treat every service API as a promise to hide its internals

Keep the seam clean. A service is autonomous only if consumers can use its capabilities without depending on its private implementation. A shared database breaks that separation: consumers bind to the schema, may write data directly, and can scatter business rules across several applications. If MusicCorp’s helpdesk, warehouse, and website each update customer records in the database, a change to customer behavior can require changes in all three places.

Design for evolution. A tolerant reader uses the fields it needs and ignores unfamiliar data, so producers can often add information without breaking consumers. Resource-based HTTP APIs can separate an external representation from internal storage, though REST is not a cure for poor design. When a breaking change is unavoidable, keep old and new endpoints available during migration rather than demanding synchronized releases.

Analysis

An API is a social contract as much as a technical interface: it tells other teams which changes they can safely ignore and which require a conversation. That makes restraint in what a service exposes a form of risk management. Compatibility is not unlimited, though. A tolerant consumer can safely ignore irrelevant additions, but it cannot infer changed business meaning. Explicitly documenting those semantics matters as much as choosing a flexible data format. The most durable interface is not the one with the fewest fields, but the one that exposes stable capabilities.

Use events to loosen coordination, then make the invisible workflow observable

Let services react locally. In choreography, a service announces that something happened, and interested services decide how to respond. When MusicCorp creates a customer, it can publish an event that prompts the loyalty, email, and postal services to do their work. New subscribers can react without requiring the customer service to know about them. This is more decoupled than a central service issuing a sequence of instructions, an approach called orchestration.

Decoupling hides the process. With choreography, no single component necessarily knows whether every step completed. Asynchronous work also needs retry limits and a way to handle messages that repeatedly fail. In a banking pricing system described in the book, a faulty request repeatedly crashed workers and returned to the queue. A dead letter queue, sometimes called a message hospital, can isolate such messages for inspection and possible replay.

Analysis

Choreography distributes decision-making, but distribution does not make coordination disappear. It moves coordination from a central controller into event definitions, monitoring, and the shared understanding of what each service is responsible for. This resembles decentralized systems in other fields: local actors gain flexibility, while the whole system needs ways to detect whether its global purpose is being met. Events are most useful when their meaning is durable and their effects can be traced. For short, simple workflows, a direct request can still be clearer than an elaborate event architecture.

Carve monoliths apart one low-risk seam at a time

Find seams before splitting. A seam is a part of a codebase that can be changed in relative isolation. Grouping existing code into packages that reflect business contexts can reveal dependencies and expose mismatches before they become network boundaries. Choose an early extraction for a concrete reason, such as a fast-changing capability, a team handoff, a security need, or a distinct technology requirement.

Separate data deliberately. Databases often hide the hardest coupling. A finance report may read catalog tables directly, or unrelated business concepts may share one table. Replace cross-context access with an API, separate schemas, and check whether foreign keys or transactions encode assumptions that the application still needs. Splitting a transaction across services means deciding how to retry or compensate when only part succeeds. Reporting may need its own data feeds or event-driven projections rather than direct access to every service database.

Analysis

Incremental decomposition is a way to manage uncertainty, not simply a slower route to a predetermined architecture. Each extraction tests whether the proposed boundary works in actual use, while limiting the damage from a mistaken assumption. This is especially important because database constraints can embody business rules that nobody has written down. A staged migration makes those rules visible before code and data are separated. The discipline is to measure the cost of each seam, including operational and consistency costs, rather than treating every reduction in code size as progress.

Let architects set guardrails, then let teams learn inside them

Plan for change, not perfection. The evolutionary architect shapes broad boundaries and shared rules, much like a planner who guides how districts connect without specifying every building. Strategic goals describe where the organization is headed; principles translate those goals into durable guidance; practices give teams concrete, changeable ways to apply it. Standardize especially where services meet, such as monitoring formats, API conventions, and failure handling.

Stay close to the work. Architects should spend time with delivery teams and understand what their choices cost in practice. Conway’s law describes how a system tends to reflect the communication paths of the organization building it. Teams aligned with business contexts and responsible for their services can make local decisions faster. Where services must be shared, an internal open-source model lets other teams propose changes while a core team reviews them.

Analysis

The planning metaphor is useful because it separates boundaries from implementation detail. It also places a check on both extremes: a central authority that dictates every technical choice, and total local freedom that produces incompatible systems. The test for a guardrail is whether it protects an important system property while leaving meaningful room for teams to solve their own problems. Organizational alignment is not a mechanical guarantee of good architecture. Teams also need skills, trust, and clear ownership, or nominal autonomy becomes a responsibility without the means to act.

Automate each service's path to production before multiplying services

Make independent releases real. Continuous integration checks changes frequently and creates a verified artifact. Continuous delivery models the route that artifact takes toward production. In a microservice system, a separate build and pipeline for each service makes it easier to identify what changed and release it alone. Build once, then promote the same artifact through environments, keeping environment-specific configuration outside it.

Invest before scaling out. Automated provisioning, deployment, and monitoring reduce the burden of many services. RealEstate.com.au spent substantial effort on tooling before its service count accelerated: it moved two services to production in its first three months, then 10 to 15 in the next three, and had roughly 60 to 70 services after 18 months. Immutable images and one service per host or container can make deployments easier to reproduce, provided automation keeps them manageable.

Analysis

Automation changes the economics of architectural choice. Without it, every additional service multiplies human coordination and operational toil; with it, repeated tasks become predictable and reviewable. The RealEstate.com.au example is valuable because it shows that infrastructure investment preceded the rapid increase in services. Yet automation is not automatically a virtue: a brittle pipeline can reproduce mistakes at high speed. The right measure is not how many steps have been scripted, but whether teams can trace an artifact from source to production and recover safely when a deployment behaves differently than expected.

Test consumer promises more than sprawling end-to-end scenarios

Use different test scopes. The Test Pyramid places many fast, narrow unit tests at the base, service tests in the middle, and a small number of broad end-to-end tests at the top. Wider tests exercise more production components, but run more slowly and make failures harder to diagnose. Large suites can become flaky when networks, environments, or other services fail for reasons unrelated to the behavior being checked.

Check the contract directly. A consumer-driven contract records what a particular client expects from a service and runs that expectation against the service itself. If the customer service changes in a way that breaks the helpdesk, the failure identifies the affected consumer without requiring a full system test. Keep end-to-end tests for a few important user journeys. Blue-green deployment can then verify a new version before sending it real traffic, while canary releases compare new behavior under a controlled portion of production load.

Analysis

The strongest insight is that confidence comes from layered evidence, not from one enormous test suite. Contract tests focus attention on compatibility, while narrow tests make defects cheaper to locate. This is a useful application of fault isolation to quality assurance: reduce the number of possible causes when a check fails. Contracts still depend on honest, current examples of how consumers use an API. They cannot reveal every emergent interaction across a system, so a small number of representative journeys and production monitoring remain important complements.

Trace user journeys, not just machines, when production misbehaves

Collect a system-wide view. At scale, useful monitoring combines host metrics, service-level measures, and centrally searchable logs. Track response times and errors for each service and its dependencies, then aggregate those signals while preserving the ability to inspect individual instances. A CPU spike alone says little unless it can be connected to a user-visible problem.

Test meaning in production. Semantic monitoring uses synthetic transactions that imitate important user actions. In a trading system, a periodic fake market event was sent through the real processing chain; the test alerted the team if the expected result did not appear. Correlation IDs give each initiating request a shared identifier that follows it across services and logs, making a distributed call chain reconstructable. Standard formats make those signals usable across teams and tools.

Analysis

Monitoring is most effective when it answers a question someone can act on. A host dashboard helps diagnose infrastructure, while a synthetic journey asks whether the service still performs work that matters to a user. Correlation IDs connect these levels by preserving context as requests cross boundaries. This is a shift from collecting more telemetry to building a causal narrative from it. Synthetic checks must be carefully isolated from real customer actions, however. A test that accidentally places genuine orders is not observability; it is an incident generator.

Assume every dependency can fail without taking its callers down

Expect slow failure. A classified-ads system handling thousands of requests per second was brought down when a rarely used legacy service became slow. Waiting callers filled a shared connection pool, and concurrent connections rose from about 40 to 800 in five minutes. The problem was not simply that a dependency failed; its slowness consumed resources in the calling system.

Contain the damage. Set timeouts on every remote call, isolate downstream services with separate connection pools, and use circuit breakers to stop repeated calls to an unhealthy dependency. A bulkhead is a resource boundary that prevents one failing component from exhausting capacity needed by others. Decide how the user experience should degrade when a service is unavailable. Idempotent operations, whose business effect does not repeat when retried, make recovery from uncertain delivery safer.

Analysis

The incident illustrates a basic systems principle: waiting is work when it ties up finite resources. A downstream service that is merely slow can be more dangerous than one that immediately refuses requests, because delay accumulates across callers. Timeouts, isolated pools, and circuit breakers limit that accumulation, but they cannot decide which features should remain available. That decision requires knowledge of business priorities. Reliability therefore combines engineering controls with an explicit ranking of capabilities, so scarce capacity protects essential work first.

Choose consistency per operation, not with a system-wide slogan

Name the trade-off. The CAP theorem describes the limits of a distributed system during a network partition: it cannot guarantee both a consistent view of data and a response to every request while also tolerating that partition. If a catalog entry is briefly stale, continued availability may be acceptable. For an operation that spends loyalty points, stale information could allow a customer to use more than the available balance.

Ask what the business can tolerate. Requirements for response time, availability, and data durability differ by service and even by operation. Replicas can make reads easier to scale, but may briefly return old data. More elaborate approaches to distributed consistency add coordination and failure modes. The decision should reflect consequences for users, not a preference for a fashionable database. Physical reality also limits perfect records: a damaged item can make an inventory count wrong even when every database transaction succeeds.

Analysis

This section is valuable because it converts a theorem into a requirements conversation. Technical teams can describe the costs of stale reads, blocked requests, or failed writes, but only the business context can rank those costs. The distinction between an operation and an entire service is particularly important: a system may tolerate stale display data while requiring stronger guarantees for a balance-changing action. Consistency is not a synonym for correctness in every setting. A perfectly synchronized model of the wrong or outdated real-world facts is still wrong.

Apply security in layers, and store less sensitive data

Match protection to exposure. Authentication verifies who a person or service is; authorization determines what that identity may do. A gateway can simplify single sign-on, but services still need to enforce sensitive, fine-grained permissions. The confused deputy problem arises when a trusted service is tricked into using its access to retrieve information that the original user should not see. Secure transport, network controls, operating-system patching, and encryption at rest provide additional defenses.

Reduce what can be stolen. Use established cryptographic implementations and keep encryption keys separate from the protected data. Encrypt backups as well as live stores, and avoid putting sensitive details in logs. Datensparsamkeit is the principle of retaining only the personal information needed for the business purpose or legal obligation. Less stored information means less material to expose in a breach and less to protect indefinitely.

Analysis

Security is often treated as a perimeter problem, but microservices create many internal boundaries where identity and permissions matter. A gateway can centralize authentication while still leaving authorization close to the business action, where its meaning is clearest. Data minimization adds a different kind of protection: it removes assets from the threat surface instead of merely adding locks. That principle can conflict with the commercial appetite to collect data for future use. The useful question is whether that speculative value justifies the long-lived privacy and security obligations.

Analysis

The book’s central argument is not that software should be divided into many small processes. It is that the capacity to change safely should shape both architecture and organization. A service boundary is valuable when it separates decisions that change for different reasons, lets a team own a coherent business capability, and reduces the need for synchronized releases. If the boundary does not accomplish those things, it is mostly a new network hop with a new failure mode.

That framing explains why the book repeatedly joins technical design to human practice. APIs determine how much teams must coordinate. Build pipelines determine whether independent deployment is real or merely a diagram. Monitoring determines whether decentralization remains governable. The architect’s role is therefore less about predicting a finished system than creating constraints, tools, and feedback loops that make local decisions safe.

The hardest work is not choosing REST, containers, or a service registry. It is discovering stable responsibilities in a changing domain, especially when existing data structures disguise business rules. Incremental extraction is persuasive because it turns architecture into a series of testable decisions. It also provides an exit when an early boundary proves wrong, instead of making a flawed decomposition permanent through organizational commitment.

There is a genuine tension at the book’s center. Autonomy asks for variation, while reliability asks for common standards. Newman’s resolution is selective: permit local freedom inside services, but standardize the interfaces and operational behaviors needed to understand the whole. This is not a universal formula. The right balance depends on team maturity, business risk, and the cost of coordination. The durable lesson is to treat every architectural split as an exchange: less coupling in one place, more distributed complexity in another. The exchange is worthwhile only when it improves the organization’s ability to learn, adapt, and deliver.

Summary in 30 Seconds
Split systems only where separate business capabilities need to change independently; each new boundary also adds network failures, deployment work, and monitoring needs. Define services around domain responsibilities, expose stable APIs, and extract a monolith incrementally. Independent releases depend on automated pipelines, contract-focused tests, and shared observability. Protect callers with timeouts, isolation, and controlled retries. Choose consistency and security measures according to each operation's risks, and retain less sensitive data.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.22 out of 5
Average of 5k+ ratings from Goodreads and Amazon.

Building Microservices receives mixed reviews, with many praising its comprehensive overview of microservices concepts and practical advice. Readers appreciate the author's cautious approach and real-world examples. Critics note the book's lack of depth on some topics and its potential to oversell microservices. Many find it valuable for beginners but less useful for experienced architects. The book covers various aspects of microservices, including design, deployment, testing, and scaling. Some readers wished for more concrete implementation details, while others valued its high-level perspective on software architecture.

Your rating:
4.6
534 ratings
Want to read the full book?

Glossary

Bounded context

Business responsibility boundary

A bounded context is a domain area with a specific responsibility and explicit limits around the models and behavior it owns. It defines what information is private, what is shared through an interface, and how a business concept is understood within that area. It is a useful starting point for identifying a cohesive service boundary.

Consumer-driven contracts (CDCs)

Executable consumer expectations

Consumer-driven contracts capture a service consumer’s expectations of a provider in executable tests. Those tests run against the provider, often as part of its build, to reveal changes that would break a known consumer. The consumer and provider teams should agree on the contract so failures initiate a focused discussion about compatibility.

Choreography

Event-led service collaboration

Choreography is a way to coordinate a process across services without a central controller issuing every instruction. A service emits an event describing something that happened, and interested services respond according to their own responsibilities. This reduces direct knowledge between participants but makes end-to-end monitoring and process tracking more important.

Strangler Application Pattern

Incremental legacy replacement

The Strangler Application Pattern replaces a legacy system gradually. A new application or set of services intercepts calls intended for the old system and routes each capability either to existing functionality or to a replacement. As new functionality takes over, legacy components can be retired without requiring a single high-risk rewrite.

Evolutionary architect

Guide for adaptable systems

An evolutionary architect guides a system’s direction while accepting that requirements, technology, and understanding change. Rather than prescribe every implementation detail in advance, this role defines broad boundaries, principles, and practices, then adjusts them through collaboration with delivery teams. The goal is a system that remains useful and workable for both users and developers.

Conway's law

Organization shapes system design

Conway's law describes the tendency for systems to reflect the communication structure of the organizations that create them. Teams with clear, relatively independent communication paths often produce modular systems, while shared ownership and difficult coordination can create tightly connected designs. The observation suggests aligning service ownership and team structure around coherent business responsibilities.

Semantic monitoring

Checks meaningful system behavior

Semantic monitoring checks whether a system performs meaningful work, rather than inferring health only from infrastructure statistics. Synthetic transactions imitate important user or business actions and verify that expected outcomes occur. They can reveal failures across a chain of services, while host and service metrics help diagnose the underlying cause.

Bulkhead

Resource failure isolation

A bulkhead limits the resources one dependency or component can consume, preventing its failure from exhausting capacity needed elsewhere. Separate connection pools for separate downstream services are one example. A bulkhead may allow one feature to fail while other parts of the application continue operating.

Circuit breaker

Stops calls to unhealthy dependencies

A circuit breaker monitors calls to a downstream service and stops sending requests after failures exceed a threshold. While open, it fails calls quickly instead of allowing repeated slow or unsuccessful requests to consume resources. After a pause, it tests whether the dependency has recovered and resumes traffic if it is healthy.

CAP theorem

Distributed failure trade-off

The CAP theorem describes a trade-off during a network partition in a distributed system. A system cannot guarantee both consistent answers across nodes and a response to every request while also tolerating the partition. The practical choice depends on the operation: some uses tolerate stale data, while others may need to reject requests rather than risk inconsistent state.

Datensparsamkeit

Data minimization principle

Datensparsamkeit is the principle of collecting and retaining only the personal data needed to fulfill a business purpose or legal requirement. It reduces the amount of information exposed if systems are breached and limits the burden of protecting data over time. The concept originated in German privacy legislation.

FAQ

What's Building Microservices by Sam Newman about?

  • Microservices Architecture: The book explores microservices, which are small, autonomous services that collaborate to form a system. It highlights how this architecture can enhance software delivery speed and flexibility.
  • Business Domain Focus: Microservices are modeled around business domains, aligning software design with business needs and avoiding issues of monolithic architectures.
  • Practical Guidance: Sam Newman provides real-world examples from companies like Netflix and Amazon, offering a comprehensive guide for adopting or understanding microservices.

Why should I read Building Microservices by Sam Newman?

  • Comprehensive Resource: It covers design, development, deployment, testing, and maintenance of microservices, making it ideal for those transitioning from monolithic systems.
  • Real-World Examples: The book includes insights from organizations that have successfully implemented microservices, providing practical perspectives and lessons learned.
  • Continuous Learning: It encourages embracing continuous learning to keep up with the fast-evolving nature of microservices technology and practices.

What are the key takeaways of Building Microservices by Sam Newman?

  • Microservices Benefits: The book outlines benefits like improved scalability, resilience, and quick adoption of new technologies due to service autonomy.
  • Loose Coupling and High Cohesion: Emphasizes designing services to be loosely coupled and highly cohesive, facilitating easier maintenance and updates.
  • Integration Strategies: Discusses synchronous and asynchronous communication strategies, crucial for maintaining service autonomy and effective collaboration.

What is the definition of microservices according to Building Microservices by Sam Newman?

  • Small, Autonomous Services: Defined as "small, autonomous services that work together," highlighting their independence and functionality without reliance on others.
  • Business Functionality Focus: Each microservice handles a specific business capability, aligning with organizational goals and prioritizing work effectively.
  • Decoupled Communication: Services communicate through well-defined APIs, maintaining loose coupling and enabling independent development and deployment.

How does Building Microservices by Sam Newman suggest modeling services?

  • Bounded Contexts: Introduces bounded contexts from Domain-Driven Design to define service boundaries, with each context representing a specific responsibility.
  • Loose Coupling and High Cohesion: Stresses that related functionality should reside within the same service, while unrelated functionality should be separated.
  • Iterative Approach: Recommends refining service boundaries over time to accommodate changes in business requirements and technology.

What are the integration strategies discussed in Building Microservices by Sam Newman?

  • Synchronous vs. Asynchronous: Contrasts synchronous communication, where a service waits for a response, with asynchronous communication, where services operate independently.
  • Event-Driven Architecture: Advocates for event-driven architectures, where services emit events to signal state changes, promoting loose coupling.
  • REST and RPC: Discusses RESTful APIs and Remote Procedure Calls for service communication, emphasizing technology-agnostic APIs for flexibility.

What are the challenges of deploying microservices as outlined in Building Microservices by Sam Newman?

  • Increased Complexity: Warns of the complexity due to interdependencies between services, which can lead to deployment challenges without proper management.
  • Continuous Integration and Delivery: Emphasizes robust CI/CD practices to manage microservices effectively, ensuring quick and reliable deployments.
  • Monitoring and Management: Suggests comprehensive monitoring solutions to track the health and performance of each service independently.

How does Building Microservices by Sam Newman address testing in microservices?

  • Types of Tests: Categorizes tests into technology-facing and business-facing, including unit, integration, and end-to-end tests for service reliability.
  • Consumer-Driven Contracts: Introduces consumer-driven contracts to validate service interactions, ensuring changes in one service don't break dependent services.
  • Automated Testing: Advocates for automated testing to maintain quality and speed in deployment, allowing confident release of changes.

What is the significance of Conway’s Law in Building Microservices by Sam Newman?

  • Organizational Structure and Architecture: Discusses Conway’s Law, which states that system designs reflect the communication structures of organizations.
  • Team Autonomy: Emphasizes organizing microservices around autonomous teams that own specific services, fostering accountability and ownership.
  • Impact on Design: Highlights the importance of aligning team structures with service boundaries for effective collaboration and faster feature delivery.

What are the best quotes from Building Microservices by Sam Newman and what do they mean?

  • Freedom to React: "Microservices give us significantly more freedom to react and make different decisions," highlighting agility compared to monolithic architectures.
  • Service Autonomy: "The golden rule: can you make a change to a service and deploy it by itself without changing anything else?" emphasizes designing independent services.
  • Postel's Law: "Be conservative in what you do, be liberal in what you accept from others," underscores flexibility in service interactions while maintaining strict internal standards.

What are some architectural safety measures discussed in Building Microservices by Sam Newman?

  • Circuit Breakers: Prevent cascading failures by stopping further calls to a failing service, allowing it to recover without being overwhelmed.
  • Bulkheads: Isolate different parts of a system to prevent a failure in one area from affecting others, enhancing resilience and stability.
  • Timeouts: Setting appropriate timeouts for service calls to avoid hanging requests, ensuring services can fail fast and recover effectively.

How does Building Microservices by Sam Newman suggest handling service discovery?

  • Dynamic Service Registries: Discusses using tools like Consul and Eureka for managing service discovery, allowing easy registration and discovery of services.
  • DNS as a Solution: Mentions DNS for service discovery, though it may not suit highly dynamic environments, suggesting load balancers to mitigate limitations.
  • Human-Friendly Interfaces: Emphasizes creating user-friendly interfaces for service discovery, aiding developers in finding and understanding available services.

About the Author

Sam Newman is a renowned software architect and consultant specializing in microservices, cloud computing, and continuous delivery. With extensive experience in the field, he has worked with numerous organizations to implement and improve their software architectures. Newman is a frequent speaker at conferences and has authored multiple books on software development. His writing style is praised for being clear, practical, and engaging, drawing from his real-world experiences. As a thought leader in the microservices space, Newman's work has significantly influenced the industry's approach to building distributed systems. His expertise extends beyond just technical aspects, encompassing organizational and cultural considerations in software development.

Download PDF

To save this Building Microservices summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.29 MB     Pages: 23

Download EPUB

To read this Building Microservices summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.39 MB     Pages: 31
Want to read the full book?
Follow
Listen10 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
600,000+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...