Composable Architecture 101: Guide to better understanding - DEV Community
Composable architecture vs Microsevices
These two architectural paradigms promote flexibility, scalability, and agility in software development, but they differ in their approach to achieving these goals. Here’s a comparison between the two:
Modular VS Service-Oriented Design: Composable architecture focuses on the composition of modular components within a single system, while microservices focus on breaking down the system into independent services.
Data management: Composable architecture typically relies on a centralized data store, while microservices emphasize decentralized data management with each service having its own database.
Autonomy and independence: Composable architecture emphasizes the composition of components to create complex systems. Components can be combined in various ways to create different configurations or compositions. Microservices place a strong emphasis on autonomy and independence of services, allowing for greater flexibility and agility in development and deployment.
Granularity vs Fault Isolation: Components in a composable architecture can vary in granularity, ranging from fine-grained microservices to larger, coarser-grained modules. Microservices promote fault isolation, as failures in one service are less likely to impact other services. As a result, failures within affected services are isolated and do not affect the entire system, which improves resilience and availability.
The Value of Becoming a Composable Business (outsystems.com)
“Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization’s communication structure.”
— Melvin E. Conway.
Composable business is a framework based on the idea of composing applications by assembling and combining Packaged Business Capabilities (PBCs, aka business components)
business composability gives organizations the agility to react and respond to market changes and adapt faster to external (and even internal)
The 4 Principles of Business Composability
- Better leadership through orchestration: Prescribing and negotiating interactions between components—to enable recomposition and forming processes.
- Greater agility through modularity: Partitioning a domain into managed components—to scale and control change.
- More speed through discovery: Ability to discover and understand design opportunities and components—to guide, track and secure change.
- Resilience through autonomy: Minimizing dependence of components from each other—to maintain integrity of change.
a PBC will be made of three types of services:
- The End-User Services will provide screens, UI blocks, and other capabilities required to deliver end-user interfaces.
- The Core Services will encapsulate the business logic required to handle the underlying business objects.
- The Foundation Services will be containing all the logic and capabilities to handle integrations and cross-functional logic.
Then, Integration Services will be used to handle external events that need to trigger some functions within the PBC and the Public APIs will be used to connect with other PBCs and external solutions.
Composable Architecture: Everything You Need to Know About Composability (ninetailed.io)
There are several characteristics that define composable architecture:
- Components are independent: Each component is self-contained and performs a specific function, and can be used in multiple configurations without relying on other components.
- Components have well-defined interfaces: The interfaces between components are clearly defined, allowing them to communicate and exchange data with each other.
- Components can be easily combined and recombined: Components can be easily combined and rearranged to create different configurations, allowing organizations to adapt their systems to changing needs and requirements.
- Components can be developed and tested separately: Because components are independent and have well-defined interfaces, they can be developed and tested separately from the rest of the system, improving the efficiency and speed of the development process.
In a composable architecture, APIs are used to define the interfaces between components, allowing them to communicate and exchange data with each other. This helps to ensure that the components are interoperable and can be easily combined and recombined to create different configurations.
Microservices, on the other hand, are small, independent units of functionality that can be developed, deployed, and maintained independently. They are designed to be lightweight and modular, making them easy to reuse and scale.
Composable architecture provides a way for organizations to build systems that are more flexible, adaptable, and efficient, helping them to stay competitive and meet the needs of their customers and stakeholders:
- Flexibility and adaptability: Composable architecture allows organizations to build systems that are more flexible and adaptable, as they can easily reuse and repurpose existing components to meet changing needs and requirements.
- Improved efficiency and speed of development: By dividing the system into small, independent components that can be developed and tested separately, composable architecture can improve the efficiency and speed of the development process.
- Reusability of components: With composable architecture, organizations can reuse and repurpose existing components rather than starting from scratch each time they need to build or modify a system. This can save time and resources and improve the overall efficiency of the organization.
- Ease of maintenance: Composable architecture can make it easier to maintain and update systems, as components can be modified and replaced individually rather than having to make changes to the entire system.
How to Implement Composable Architecture
1.When Should You Start Using Composable Architecture?
2.Identify the Components That Make Up Your System
3.Determine the Relationships Between Those Components
4.Implement the Components and Test Their Integration
Challenges and Considerations with Composable Architecture
1.Complexity of Implementation
2.Ensuring Interoperability Between Components
3.Maintaining and Updating the System Over Time
Maintaining and updating a composable architecture over time can also be a challenge, as it requires careful coordination and planning to ensure that changes to individual components do not have unintended consequences on the overall system.
A Complete Guide To Composable Software Architecture | ConnectPOS
Why Is Composable Architecture Becoming More Important?
In the present dynamic and ever-evolving business landscape, the capacity to promptly adjust and address emerging challenges and prospects holds heightened significance.
Composable software architecture offers organizations a means to construct systems that boast enhanced flexibility, adaptability, and efficiency, aiding them in remaining competitive and catering to the requirements of their customers and stakeholders.
- Flexibility and adaptability: Composable architecture allows systems to be built from individual, interchangeable components. This flexibility enables rapid adaptation to changing requirements and environments, which is crucial in the fast-paced tech landscape where businesses need to respond quickly to market demands.
- Enhanced effectiveness and accelerated pace of development: By breaking down systems into modular components, development teams can work on different parts simultaneously, speeding up the overall development process. This approach also promotes better collaboration among teams and enables more efficient resource allocation.
- Reusability of components: Composable architecture encourages the creation of reusable components that can be easily integrated into various systems. This reusability not only saves time and effort in development but also enhances consistency and reliability across different projects.
- Simplified maintenance: A modular architecture makes maintenance more manageable. Updates or changes to individual components can be made without affecting the entire system, reducing the risk of unintended consequences and making it easier to troubleshoot issues.