rhetenor/awesome-awesomeness
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
d32368fda4bc9857c54bca0e035d35a7c68372f5
awesome-awesomeness/terminal/integration
Jonas Zeunert 08e75b0f0a Updating conversion, creating readmes
2024-04-19 23:37:46 +02:00

1119 lines
404 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
 Awesome Integration !Awesome (https://awesome.re/badge.svg) (https://awesome.re)
▐ A curated list of awesome system integration software, patterns and resources.
System integration is the process of linking together different IT systems (components) to functionally cooperate as a whole.
Contents
- Projects (#projects)
 - API Management (#api-management)
 - API Design (#api-design)
 - API Documentation (#api-documentation)
 - API Gateway (#api-gateway)
 - API Testing (#api-testing)
 - BRE (#bre)
 - BPM (#bpm)
 - Data Mapping Solution (#data-mapping-solution)
 - ESB (#esb)
 - ETL (#etl)
 - Integration Frameworks (#integration-frameworks)
 - iPaaS (#ipaas)
 - MaaS (#maas)
 - Managed File Transfer (#managed-file-transfer)
 - Master Data Management (#master-data-management)
 - Messaging (#messaging)
 - RPA (#rpa)
 - Self-Service Integration (#self-service-integration)
 - Workflow engine (#workflow-engine)
- Integration Patterns (#integration-patterns)
 - Enterprise Integration Patterns (#enterprise-integration-patterns)
 - Integration Architecture Patterns (#integration-architecture-patterns)
 - Microservice API Patterns (#microservice-api-patterns)
 - SOA Patterns (#soa-patterns)
- Resources (#resources)
 - API Specification (#api-specification)
 - Articles (#articles)
 - Certifications (#certifications)
 - Connectors (#connectors)
 - Data Formats (#data-formats)
 - Integration Styles (#integration-styles)
 - Market Analysis (#market-analysis)
 - Protocols (#protocols)
 - Standard APIs (#standard-apis)
 - Structure and Validation (#structure-and-validation)
――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――
Projects
API Management
API Management solutions offer a comprehensive approach to handling the entire API lifecycle. They enable developers to create, publish, secure, and monitor APIs, ensuring efficient and reliable communication between systems. With 
features such as authentication, rate limiting, and analytics, these tools provide centralized control and enhanced security, making it easier to manage and scale APIs across different platforms and environments.
- Akana API Management Platform (https://www.akana.com/products/api-platform) - A comprehensive platform that accelerates digital transformation, manages the full API lifecycle, and ensures compliance while deploying across multiple 
clouds.
- Anypoint Platform (https://www.mulesoft.com/platform/api/manager) - A single, unified platform from Mulesoft that combines API management and integration capabilities, allowing you to design, build, and manage APIs with ease.
- Amazon API Management (https://aws.amazon.com/api-gateway/api-management/) - A secure and scalable API management solution that enables you to monitor and manage APIs in a flexible and efficient way.
- Amplify API Management Platform (https://www.axway.com/en/products/amplify-api-management-platform) - An open platform for API management from Axway, which provides comprehensive API management capabilities and allows you to build, 
run, and manage APIs with ease.
- Apigee (https://cloud.google.com/apigee) - A leading API management solution from Google that provides comprehensive API management capabilities and helps you create, secure, and scale APIs with ease.
- Azure API Management (https://azure.microsoft.com/en-us/services/api-management/) - A hybrid, multicloud management platform for APIs across all environments, which enables you to manage APIs with ease, secure them, and gain insights 
into their performance.
- DigitMarket API Manager (https://www.torryharris.com/products/digitmarket-api-manager-for-api-management) - A complete package from Torry Harris that helps you manage your APIs and turn them into tools that can drive your business 
forward.
- Gravitee.io API Management (⭐133) (https://github.com/gravitee-io/gravitee-api-management) - A flexible, lightweight, and open-source API management solution that provides comprehensive API management capabilities and helps you 
manage your APIs with ease.
- IBM API Connect (https://www.ibm.com/cloud/api-connect) - A complete, intuitive, and scalable API platform that allows you to create, expose, manage, and monetize APIs across clouds.
- Kong Enterprise (https://konghq.com/products/kong-enterprise) - A comprehensive service connectivity platform that provides a range of API management capabilities and allows you to manage APIs, microservices, and service meshes with 
ease.
- Layer7 API Management (https://www.broadcom.com/products/software/api-management) - A continuous API management solution from Broadcom that provides comprehensive API management capabilities and helps you manage APIs throughout their 
lifecycle.
- Red Hat 3scale API Management (https://www.redhat.com/en/technologies/jboss-middleware/3scale) - A cloud-native API management solution that simplifies the development of APIs and makes them more flexible.
- Sensedia API Management (https://www.sensedia.com/api-management-platform) - A full lifecycle API management platform that provides comprehensive API management capabilities and helps you manage APIs throughout their lifecycle.
- TIBCO Cloud Mashery (https://www.tibco.com/products/api-management) - A cloud-native API platform from TIBCO that enables you to deploy APIs anywhere and manage them from everywhere.
- Tyk API Management (https://tyk.io/api-lifecycle-management/) - A powerful API management solution that allows you to connect, build, and control APIs with ease.
- webMethods API (https://www.softwareag.cloud/site/product/webmethods-api.html) - A comprehensive API management solution from Software AG that provides full lifecycle API management capabilities and enables you to manage APIs in both 
on-premises and cloud environments.
- WSO2 API Manager (⭐801) (https://github.com/wso2/product-apim) - A fully open-source API management platform that provides comprehensive API management capabilities and allows you to manage APIs with ease.
⬆ back to top (#contents)
API Design
API design, documentation, and life-cycle automation tools streamline the process of creating, maintaining, and evolving APIs. These tools offer efficient means to design consistent and scalable APIs, generate comprehensive 
documentation, and automate various stages of the API life-cycle, enhancing developer experience and promoting API adoption.
- Dredd (⭐4.1k) (https://github.com/apiaryio/dredd) - Validate API description docs against backend implementation using this language-agnostic CLI tool.
- OpenAPI-GUI (⭐1.3k) (https://github.com/Mermade/openapi-gui) - Create and validate OpenAPI specs with ease using this intuitive graphical user interface.
- OpenAPI Diff (⭐743) (https://github.com/OpenAPITools/openapi-diff) - Compare OpenAPI specs with version control and visualize the differences in HTML or Markdown format.
- OpenAPI Generator (⭐19k) (https://github.com/OpenAPITools/openapi-generator) - Automate the creation of API client libraries, server stubs, documentation and config files with this powerful OpenAPI Spec tool.
- OpenAPI Style Validator (⭐194) (https://github.com/OpenAPITools/openapi-style-validator) - Ensure that your OpenAPI specs meet your organization's standards with this flexible and customizable style validator.
- Spectral (⭐2.2k) (https://github.com/stoplightio/spectral) - Detect and fix errors in your JSON/YAML files using this linter tool that supports OpenAPI 3.0 & 2.0 and AsyncAPI.
- Swagger Editor (⭐8.6k) (https://github.com/swagger-api/swagger-editor) - Create, describe, and document your API with ease using this open source editor built specifically for OpenAPI-based APIs.
- Zally (⭐874) (https://github.com/zalando/zally) - Ensure the quality of your OpenAPI specs with this linter tool that provides extensive analysis and feedback.
⬆ back to top (#contents)
API Documentation
Explore a collection of tools and platforms designed to create, maintain, and present clear, concise, and user-friendly documentation for APIs. These resources facilitate seamless collaboration between developers and enable effective 
communication of API functionalities and specifications.
- DapperDox (⭐392) (https://github.com/DapperDox/dapperdox) - An open-source API documentation generator and server for OpenAPI/Swagger specifications, with customizable documentation, automated updates, and easy sharing.
- OpenAPI Explorer (⭐281) (https://github.com/Rhosys/openapi-explorer) - A tool for generating user interfaces from OpenAPI specifications, making it easier for software engineers to visualize and interact with APIs.
- RapiDoc (⭐1.5k) (https://github.com/rapi-doc/RapiDoc) - A tool that generates customizable, interactive API documentation from OpenAPI Specification, with a range of design options.
- Redoc (⭐22k) (https://github.com/Redocly/redoc) - An open-source tool for generating documentation from OpenAPI (fka Swagger) definitions, with customizable themes, language support, and branding.
- Slate (⭐35k) (https://github.com/slatedocs/slate) - A powerful tool that creates static API documentation from markdown, with API reference docs and code samples.
- Stoplight Elements (⭐1.4k) (https://github.com/stoplightio/elements) - Beautiful API documentation powered by OpenAPI and Markdown. Use these UI components to create API reference documentation, or more complete documentation with 
Markdown articles covering tutorials, how-to guides, etc.
- SwaggerHub (https://swagger.io/tools/swaggerhub/) - An integrated API design and documentation platform built for teams, with versioning, testing automation, and integration with popular API tools.
- Swagger UI (⭐25k) (https://github.com/swagger-api/swagger-ui) - An intuitive tool for exploring and interacting with APIs, with API specification visualization, endpoint exploration, and built-in interactive console.
- SpectaQL (⭐1k) (https://github.com/anvilco/spectaql) - A Node.js library that generates static documentation for a GraphQL schema from various sources, including live endpoint, query result, and SDL files.
⬆ back to top (#contents)
API Gateway
API Gateways act as intermediaries between client applications and backend services, enabling key features such as request routing, authentication, rate limiting, and caching. They simplify the process of managing, securing, and 
monitoring APIs by providing a unified entry point for various services.
- Apinto (⭐1.2k) (https://github.com/eolinker/goku) - A Golang-based microservice gateway that provides dynamic routing, service orchestration, multi-tenancy management, and API access control.
- Ambassador Edge Stack (https://www.getambassador.io/products/edge-stack/api-gateway/) - A Kubernetes-native API Gateway that helps manage APIs at scale with its customizable routing, authentication, and rate-limiting features.
- Apache APISIX (⭐13k) (https://github.com/apache/apisix) - A dynamic, real-time, and high-performance API Gateway that leverages Apache plugins for enhanced functionality.
- Gloo Edge (⭐3.9k) (https://github.com/solo-io/gloo) - An Envoy Proxy-based API Gateway that provides advanced traffic management, security, and observability features for modern microservices architectures.
- Kong API Gateway (⭐37k) (https://github.com/Kong/kong) - A cloud-native, platform-agnostic, and scalable API Gateway that supports plugins for easy integration with third-party services.
- KrakenD API Gateway (⭐1.7k) (https://github.com/devopsfaith/krakend-ce) - An ultra-high performance API Gateway that leverages middlewares for fast and efficient API management.
- Ocelot (⭐8.1k) (https://github.com/ThreeMammals/Ocelot) - A .NET API Gateway that provides a simple and elegant way to manage APIs with its intuitive routing and middleware configuration.
- Spring Cloud Gateway (⭐4.3k) (https://github.com/spring-cloud/spring-cloud-gateway) - An API Gateway built on top of the Spring ecosystem, providing advanced routing and filtering features for Spring applications.
- Traefik (⭐47k) (https://github.com/traefik/traefik) - A modern, open-source API Gateway that is designed to handle dynamic container environments such as Kubernetes, Docker Swarm, and Mesos. It provides load balancing, SSL/TLS 
termination, rate limiting, circuit breaking, and more.
- Tyk API Gateway (⭐9.2k) (https://github.com/TykTechnologies/tyk) - An open source Enterprise API Gateway that supports REST, GraphQL, TCP, and gRPC protocols. It provides advanced API management features such as rate limiting, access
control, and analytics.
⬆ back to top (#contents)
API Testing
The API testing tools section provides a list of software tools and frameworks that developers can use to test REST APIs and message brokers. This section includes GUI clients for testing REST APIs and message brokers, mocking tools for
simulating API responses, as well as various testing tools and frameworks to automate testing processes.
- API clients
 - Advanced REST Client (⭐1.3k) (https://github.com/advanced-rest-client/arc-electron) - An open-source API tool designed for testing and debugging RESTful web services.
 - curl (⭐34k) (https://github.com/curl/curl) - Command-line tool for transferring data with URLs over various protocols.
 - curlie (⭐2.6k) (https://github.com/rs/curlie) - Frontend to curl with the ease of use of httpie without compromising on performance and features.
 - HTTPie (⭐31k) (https://github.com/httpie/httpie) - User-friendly command-line HTTP client that simplifies HTTP request/response inspection and manipulation.
 - Insomnia (⭐33k) (https://github.com/Kong/insomnia) - Cross-platform HTTP and GraphQL client designed to make API testing and debugging easier.
 - Postman (https://www.postman.com/product/api-client/) - Comprehensive tool for simplifying API development and testing processes with features such as making HTTP requests, generating mock servers, and creating API documentation.
 - resty (⭐2.6k) (https://github.com/micha/resty) - A Lua framework for building HTTP clients that provides a shell interface for interacting with REST services.
 - SoapUI (⭐1.4k) (https://github.com/SmartBear/soapui) - Open-source web service testing application designed for testing SOAP and REST web services.
- MQ clients
 - JMSToolBox (⭐190) (https://github.com/jmstoolbox/jmstoolbox) - Universal JMS client designed to interact with a wide range of JMS-based message brokers.
 - kcat (⭐5.2k) (https://github.com/edenhill/kcat) - Generic non-JVM producer and consumer for Apache Kafka, functioning as a netcat for Kafka.
 - MQTT Explorer (⭐2.7k) (https://github.com/thomasnordquist/MQTT-Explorer) - All-round MQTT client with a structured topic overview, suitable for debugging and testing MQTT-based systems.
 - Offset Explorer (https://www.kafkatool.com) - GUI application for managing and using Apache Kafka clusters, formerly known as Kafka Tool.
 - Service Bus Explorer (⭐1.9k) (https://github.com/paolosalvatori/ServiceBusExplorer) - GUI app for Azure Service Bus, offering advanced features like import/export functionality and the ability to test topic, queues, subscriptions, 
relay services, notification hubs, and events hubs.
- Mocking tools
 - Imposter (⭐341) (https://github.com/outofcoffee/imposter) - Mock server for REST APIs, OpenAPI (and Swagger) specifications, SOAP web services (and WSDL files), Salesforce and HBase APIs.
 - Microcks (⭐1.1k) (https://github.com/microcks/microcks) - Open-source Kubernetes-native tool for API mocking and testing, supporting AsyncAPI, OpenAPI, Postman Collections, etc.
 - Mockable (https://www.mockable.io/) - Simple configurable service to mock out RESTful API or SOAP web-services.
 - Mockoon (⭐5.8k) (https://github.com/mockoon/mockoon) - Easy-to-use tool for designing and running mock REST APIs.
 - MockServer (⭐4.4k) (https://github.com/mock-server/mockserver) - Easy mocking of any system you integrate with via HTTP or HTTPS.
 - Mocky (⭐2k) (https://github.com/MockyAbstract/Mocky) - Free and unlimited online service for generating custom HTTP responses.
 - Prism (⭐3.9k) (https://github.com/stoplightio/prism) - Open-source HTTP mock server that can mimic your API's behavior as if you already built it.
 - WireMock (⭐6k) (https://github.com/tomakehurst/wiremock) - Mock your APIs for fast, robust, and comprehensive testing.
- Testing tools and frameworks
 - Apache JMeter (⭐7.9k) (https://github.com/apache/jmeter) - Open-source Java-based load testing tool that can be used to test the performance and scalability of web applications, databases, and other network services.
 - Gatling (⭐6.2k) (https://github.com/gatling/gatling) - An open-source load testing tool that allows users to write and run load tests as code, providing detailed performance reports to optimize system performance.
 - Karate (⭐7.8k) (https://github.com/intuit/karate) - Open-source tool that combines API test-automation, mocks, performance-testing, and even UI automation into a single, unified framework.
 - Pyresttest (⭐1.1k) (https://github.com/svanoort/pyresttest) - Java DSL for easy testing of REST services.
 - REST Assured (⭐6.7k) (https://github.com/rest-assured/rest-assured) - Java DSL for easy testing of REST services.
 - Schemathesis (⭐2k) (https://github.com/schemathesis/schemathesis) - Python library for property-based testing of API schemas.
 - Taurus (⭐1.9k) (https://github.com/Blazemeter/taurus) - An open-source framework for continuous testing that simplifies test execution and management through a user-friendly interface and integrates with various testing tools and 
frameworks.
⬆ back to top (#contents)
BRE
Business Rules Engines and Business Rules Management Systems (BRMS) are software systems that allow organizations to define, manage, and execute business rules. These rules are used to automate decision-making processes, enforce 
business policies, and ensure regulatory compliance. A BRMS provides a way for organizations to centrally manage their business rules and make changes to them quickly and easily, without requiring changes to the underlying code. It is a
valuable tool for businesses that need to be agile and respond quickly to changing market conditions.
- Drools (⭐5.6k) (https://github.com/apache/incubator-kie-drools) - Open-source tool that supports Decision Model and Notation (DMN) models at Conformance level 3 with an Eclipse IDE plugin for core development.
- Easy Rules (⭐4.7k) (https://github.com/j-easy/easy-rules) - Simple Java rules engine for straightforward rule processing.
- NxBRE (⭐129) (https://github.com/ddossot/NxBRE) - Open-source rule engine specifically designed for the .NET platform.
- OpenL Tablets (⭐143) (https://github.com/openl-tablets/openl-tablets) - Open-source business rules engine (BRE, BRMS) and decision management system that allows users to define, manage, and execute business rules and decision tables.
⬆ back to top (#contents)
BPM
BPM solutions are software tools that help businesses streamline and automate their operational processes to improve efficiency and productivity. These solutions typically provide features such as process modeling, workflow management, 
task automation, and reporting. They can be used to automate a wide range of processes, from simple tasks like data entry to complex workflows involving multiple departments and stakeholders.
- Appian BPM Suite (https://appian.com/platform/complete-automation/business-process-management-bpm.html) - A platform that combines low-code development with process management, allowing both IT and citizen developers to construct 
process-centric and case-centric applications.
- Genpack Cora SeQuence (https://www.genpact.com/cora/sequence) - A tool for orchestrating business processes, driving business agility and improving cost efficiency.
- IBM Business Automation Workflow (https://www.ibm.com/products/business-automation-workflow) - A comprehensive business process management platform for developing and administering business applications.
- Oracle BPM Suite (https://www.oracle.com/middleware/technologies/bpm.html) - An integrated environment for developing, administering, and using business applications that are centered around business processes.
- Pega Platform (https://www.pega.com/products/platform) - A platform for business process management and robotic process automation (RPA) with advanced workforce analytics.
- Red Hat Process Automation Manager (https://www.redhat.com/en/technologies/jboss-middleware/process-automation-manager) - Application development platform that enables developers and business experts to create cloud-native 
applications that automate business operations.
- SAP Process Orchestration (https://www.sap.com/products/process-orchestration.html) - A business process management offering and application infrastructure. 
- TIBCO BPM Enterprise (https://www.tibco.com/products/business-process-management) - Business process management platform that offers capabilities for process automation, documentation, human capital management, process patterns, and 
predictive operations analytics.
⬆ back to top (#contents)
Data Mapping Solution
Data Mapping tools are used to define and transform data between different systems, applications, and formats. These tools allow for the mapping of data from source to target, allowing for data transformation and integration. This 
section covers different data mapping solutions that can be used to facilitate data mapping and transformation processes for different use cases.
- AltasMap (⭐179) (https://github.com/atlasmap/atlasmap) - A web-based data mapping solution that simplifies integration between Java, XML, CSV, and JSON data sources. Its interactive user interface makes configuring integrations easy.
- Altova MapForce (https://www.altova.com/mapforce) - A graphical data mapping tool that can handle any-to-any conversion and integration tasks. It simplifies complex mapping tasks, enabling software engineers to complete projects 
faster.
- JOLT (⭐1.4k) (https://github.com/bazaarvoice/jolt) - A Java-based JSON-to-JSON transformation library that uses a JSON document as the "specification" for the transform. JOLT provides a simple way for software engineers to transform 
JSON data.
- JSLT (⭐604) (https://github.com/schibsted/jslt) - A complete query and transformation language for JSON that is inspired by jq, XPath, and XQuery. With JSLT, software engineers can quickly and easily transform JSON data to meet their
needs.
⬆ back to top (#contents)
ESB
Enterprise Service Bus (ESB) solutions facilitate the integration of disparate systems and applications by providing a communication layer that allows them to exchange information. ESBs offer a range of capabilities such as message 
routing, transformation, protocol conversion, and data mediation. They typically support various messaging patterns and communication protocols and provide a centralized platform for managing and monitoring message traffic.
- Anypoint Platform (https://www.mulesoft.com/platform/enterprise-integration) - A comprehensive API management and integration platform that simplifies connecting applications from Mulesoft.
- Apache ServiceMix (https://servicemix.apache.org/) - An open-source integration container that combines the functionality of Apache ActiveMQ, Camel, CXF, and Karaf, providing a flexible solution.
- ArcESB (https://www.arcesb.com/integration/) - A versatile integration platform that seamlessly synchronizes data across applications, integrates with partners, and provides data accessibility.
- IBM App Connect (https://www.ibm.com/cloud/app-connect) - An integration platform that can connect applications, irrespective of the message formats or protocols they use, formerly known as IBM Integration Bus.
- NServiceBus (⭐2k) (https://github.com/Particular/NServiceBus) - A .NET-based service bus that offers an intuitive developer-friendly environment.
- Oracle Service Bus (https://www.oracle.com/middleware/technologies/service-bus.html) - An integration platform that connects, virtualizes, and manages interactions between services and applications.
- Oracle SOA Suite (https://www.oracle.com/middleware/technologies/soasuite.html) - A platform that enables system developers to set up and manage services and to orchestrate them into composite applications and business processes.
- Red Hat Fuse (https://developers.redhat.com/products/fuse/overview) - A cloud-native integration platform that supports distributed integration capabilities.
- Software AG webMethods Integration Server (https://www.softwareag.com/en_corporate/platform/integration-apis/webmethods-integration.html) - An integration platform that enables faster integration of any application.
- TIBCO BusinessWorks (https://www.tibco.com/products/tibco-businessworks) - A platform that implements enterprise patterns for hybrid integrations.
- UltraESB (https://www.adroitlogic.com/products/ultraesb/) - An ESB that supports zero-copy proxying for extreme performance utilizing Direct Memory Access and Non-Blocking IO.
- WSO2 Enterprise Integrator (⭐362) (https://github.com/wso2/product-ei) - An API-centric, cloud-native, and distributed integration platform designed to provide a robust solution for software engineers.
⬆ back to top (#contents)
ETL
ETL (Extract, Transform, Load) and ELT (Extract, Load, Transform) are processes used to integrate and consolidate data from multiple sources. This section covers a range of open source and commercial tools for performing these tasks, 
including data ingestion, transformation, and loading into data warehouses or other data storage systems.
- Apache NiFi (⭐4.3k) (https://github.com/apache/nifi) - An automated data integration platform that efficiently moves data between disparate systems.
- CloverETL (http://www.cloveretl.com/) - A comprehensive data integration software suite, ideal for data migration, warehousing, and feeding data into BI and reporting apps. 
- Hevo (https://hevodata.com/) - A fully automated, no-code data pipeline platform supporting 150+ integrations across databases, SaaS apps, cloud storage, SDKs, and streaming services.
- IBM DataStage (https://www.ibm.com/products/datastage) - A powerful data integration platform that helps businesses understand, cleanse, transform, and deliver trusted information.
- Informatica PowerCenter (https://www.informatica.com/products/data-integration/powercenter.html) - A trusted enterprise data integration and management software powering analytics for big data and cloud.
- Microsoft SSIS (https://docs.microsoft.com/en-us/sql/integration-services/sql-server-integration-services) - A reliable platform for building enterprise-level data integration and transformation solutions.
- Oracle Data Integrator (https://www.oracle.com/middleware/technologies/data-integrator.html) - A comprehensive data integration platform that covers all data integration requirements, including batch loads, integration processes, and 
SOA-enabled data services.
- Pentaho Data Integration (⭐7.3k) (https://github.com/pentaho/pentaho-kettle) - A user-friendly platform that enables users to ingest, blend, cleanse, and prepare diverse data from any source with visual tools, eliminating the need 
for coding and complexity.
- SAS Data Management (https://www.sas.com/en_us/software/data-management.html) - A robust platform that helps transform, integrate, govern, and secure data while improving its overall quality and reliability.
- Stitch (https://www.stitchdata.com/) - A simple yet powerful ETL service that integrates data from dozens of different sources, ideal for businesses of all sizes.
- Talend Data Integration (https://www.talend.com/products/integrate-data/) - A versatile platform that brings data together from multiple sources to power all your business decisions.
⬆ back to top (#contents)
Integration Frameworks
The Integration frameworks section includes software tools and libraries that help developers implement and manage integration patterns in their applications. These frameworks are based on well-established Enterprise Integration 
Patterns (EIPs), which provide a standard vocabulary and architecture for designing and implementing integration solutions. The frameworks in this section can help simplify the process of integrating different systems, applications, and
data sources by providing pre-built connectors, message routing, and transformation capabilities.
- Apache Camel (⭐5.3k) (https://github.com/apache/camel) - A powerful integration framework that uses Enterprise Integration Patterns to connect and unify different transport APIs.
- Ballerina (⭐3.5k) (https://github.com/ballerina-platform/ballerina-lang) - An open-source programming language that simplifies the creation, usage, and combination of network services.
- Frank!Framework (⭐110) (https://github.com/frankframework/frankframework) - A Low-Code Java-based messaging framework to connect your system and application data, that is completely configurable through XML configurations.
- Spring Integration (⭐1.5k) (https://github.com/spring-projects/spring-integration) - An extension of the Spring programming model that supports Enterprise Integration Patterns, allowing for streamlined integration of various systems.
⬆ back to top (#contents)
iPaaS
Integration Platform as a Service (iPaaS) is a cloud-based platform that enables businesses to integrate different systems, applications, and data sources with ease. It provides a unified platform for managing data flows between various
systems, simplifying the process of integrating different systems and automating workflows. iPaaS tools typically provide a visual interface for designing, deploying, and managing integrations, as well as pre-built connectors and APIs 
for integrating with popular systems and services.
- Anypoint Platform (https://www.mulesoft.com/platform/saas/cloudhub-ipaas-cloud-based-integration) - A powerful integration platform that combines API management and integration capabilities in a single platform, enabling software 
engineers to integrate various applications with ease.
- Boomi AtomSphere (https://boomi.com/platform) - A cloud-native, unified, open, and intelligent platform that connects everything and everyone, allowing software engineers to create and manage integrations easily.
- Jitterbit Harmony (https://www.jitterbit.com/platform/ipaas) - A comprehensive integration platform that provides pre-built templates and workflows to automate business processes. It integrates thousands of applications and simplifies
integration for software engineers.
- IBM Cloud Integration (https://www.ibm.com/cloud/integration) - A next-generation integration platform that uses AI to provide software engineers with an innovative approach to integration. This platform accelerates integration 
processes, making it faster and more scalable.
- Informatica Intelligent Cloud Services (https://www.informatica.com/products/cloud-integration.html) - A suite of cloud data management products designed to accelerate productivity and improve speed and scale. Software engineers can 
use this platform to manage data and integrate applications efficiently.
- OpenText Alloy (https://businessnetwork.opentext.com/enterprise-data-management/) - A powerful enterprise data management platform that empowers organizations to move beyond basic integration and turn data into insights and action. 
Software engineers can use this platform to manage data and improve business outcomes.
- Oracle Integration Cloud Service (https://www.oracle.com/integration/application-integration/) - A robust platform that accelerates time to go live with pre-built connectivity to any SaaS or on-premises application. Software engineers
can use this platform to simplify integration processes and streamline operations.
- SnapLogic Intelligent Integration Platform (https://www.snaplogic.com/products/intelligent-integration-platform) - A comprehensive integration platform that connects various applications and data landscapes. Software engineers can use
this platform to integrate data and applications quickly and efficiently.
- Software AG webMethods Hybrid Integration Platform (https://www.softwareag.com/en_corporate/platform/integration-apis/application-integration.html) - An all-in-one integration platform that enables software engineers to integrate all 
their applications in a single platform. This platform simplifies integration processes and improves efficiency.
- TIBCO Cloud Integration (https://www.tibco.com/products/cloud-integration) - A flexible platform that enables software engineers to integrate anything with API-led and event-driven integration. This platform empowers everyone to 
integrate anything, making integration processes faster and more efficient.
- Workato (https://www.workato.com/) - A single platform for integration and workflow automation across your organization, providing software engineers with a powerful platform for simplifying integration processes and streamlining 
operations.
⬆ back to top (#contents)
MaaS
Cloud Messaging as a Service (MaaS) refers to cloud-based messaging platforms that enable reliable, secure, and scalable communication between distributed applications and services. These platforms provide various messaging patterns 
such as publish-subscribe, request-reply, and streaming. They also offer features such as message routing, filtering, transformation, and persistence, and support various protocols and APIs for integration with different systems.
- Amazon MQ (https://aws.amazon.com/amazon-mq) - A fully managed message broker service that supports Apache ActiveMQ and RabbitMQ. It provides a reliable, secure, and scalable messaging infrastructure for your applications.
- Amazon MSK (https://aws.amazon.com/msk) - A fully managed service for Apache Kafka that simplifies the setup, scaling, and management of Kafka clusters. It provides a highly available, durable, and performant messaging service for 
your data streaming needs.
- Amazon SQS (https://aws.amazon.com/sqs) - A fully managed message queuing service that enables you to decouple and scale microservices, distributed systems, and serverless applications. It offers a reliable, secure, and highly 
available message storage and delivery system.
- Amazon SNS (https://aws.amazon.com/sns) - A fully managed pub/sub messaging service that enables you to send and receive messages between distributed systems, microservices, and event-driven serverless applications. It offers a 
flexible, scalable, and cost-effective way to notify subscribers of events and messages.
- Alibaba Cloud Message Queue for Apache Kafka (https://www.alibabacloud.com/product/kafka) - A fully managed Apache Kafka service that provides high-throughput, low-latency, and highly available message streaming for your applications.
It offers easy integration with other Alibaba Cloud services and seamless data migration.
- Alibaba Cloud Message Queue for RabbitMQ (https://www.alibabacloud.com/product/rabbitmq) - A distributed and fully managed messaging service that provides high scalability, low latency, and high throughput for your applications. It 
offers flexible deployment options, easy management, and robust security features.
- Alibaba Cloud Message Service (https://www.alibabacloud.com/product/message-service) - A distributed messaging and notification service that enables concurrent operations and message transfer between applications and decoupled 
systems. It offers high reliability, scalability, and fault tolerance for your messaging needs.
- AlibabaMQ for Apache RocketMQ (https://www.alibabacloud.com/product/mq) - A distributed message queue service that supports reliable message-based asynchronous communication among microservices, distributed systems, and serverless 
applications. It provides high availability, scalability, and durability for your message streaming needs.
- Anypoint MQ (https://www.mulesoft.com/platform/anypoint-mq-message-queue) - An enterprise-class cloud messaging service that is fully integrated with Anypoint Platform. It offers a flexible and reliable messaging infrastructure that 
enables you to integrate and orchestrate your applications and systems.
- Azure Service Bus (https://azure.microsoft.com/en-us/services/service-bus/) - A reliable cloud messaging service that offers a variety of messaging patterns, such as pub/sub and request/response, and supports a range of protocols and 
standards.
- CloudAMQP (https://www.cloudamqp.com/) - A RabbitMQ as a Service that provides a fully managed and scalable message broker service for your applications. It offers a simple and easy-to-use web-based management console, advanced 
monitoring and analytics, and seamless integration with other cloud services.
- CloudKarafka (https://www.cloudkarafka.com/) - An affordable and straightforward Kafka service that provides fully managed and scalable Kafka clusters on AWS and Google Cloud. It offers a user-friendly web-based dashboard, advanced 
security features, and seamless integration with other cloud services.
- Google Cloud Pub/Sub (https://cloud.google.com/pubsub) - A messaging and ingestion service that enables event-driven systems and streaming analytics. It provides high throughput, low latency, and reliable message delivery for your 
applications. It supports flexible messaging patterns, such as pub/sub and push/pull, and integrates seamlessly with other Google Cloud services.
- Huawei Cloud Distributed Message Service (https://www.huaweicloud.com/intl/en-us/product/dms.html) - A fully managed and high-performance message queuing service that enables reliable, flexible, and asynchronous communication between 
distributed applications. It offers high scalability, security, and durability, and supports a variety of messaging patterns and protocols.
- Huawei Cloud Distributed Message Service for Kafka (https://www.huaweicloud.com/intl/en-us/product/dmskafka.html) - A managed Apache Kafka service that provides easy setup, scaling, and management of Kafka clusters. It offers high 
availability, performance, and security, and integrates seamlessly with other Huawei Cloud services.
- IBM MQ on Cloud (https://www.ibm.com/cloud/mq) - A cloud-based messaging service that enables seamless data transfer across enterprise applications, systems, and services with ease.
- IronMQ (https://www.iron.io/mq) - An elastic message queue built specifically for the cloud, allowing for reliable and scalable message processing.
- Oracle Cloud Streaming (https://www.oracle.com/cloud/cloud-native/streaming/) - A serverless, real-time event streaming platform with Apache Kafka compatibility, delivering highly performant and cost-effective data processing.
- Solace PubSub+ Cloud (https://solace.com/products/platform/cloud/) - An all-in-one event streaming, management, and insights platform, providing complete visibility and control over your data pipeline.
- Yandex Message Queue (https://cloud.yandex.com/en/services/message-queue) - A cloud messaging service with compatibility to Amazon SQS HTTP API, making it easy to integrate with existing systems and services.
- Yandex Managed Service for Apache Kafka (https://cloud.yandex.com/en/services/managed-kafka) - A fully-managed Apache Kafka service with automated scaling, monitoring, and maintenance, providing hassle-free data streaming.
⬆ back to top (#contents)
Managed File Transfer
Managed File Transfer (MFT) solutions provide secure and reliable file transfer capabilities that help organizations meet regulatory compliance requirements, improve operational efficiency, and reduce the risk of data breaches. MFT 
software typically includes features such as encryption, digital signatures, user access controls, and detailed audit logs to ensure that data is transmitted securely and can be tracked throughout the transfer process.
- ArcESB Managed File Transfer (https://www.arcesb.com/mft/) - A comprehensive solution for enterprises seeking to streamline file transfer processes. Its user-friendly interface and powerful capabilities provide an all-in-one MFT 
solution that can efficiently handle file transfers.
- Axway Managed File Transfer (https://www.axway.com/en/products/managed-file-transfer) - Designed to simplify file transfer services for businesses, this MFT solution offers advanced features and security measures to ensure secure and 
reliable data transfer.
- Titan MFT Server (https://southrivertech.com/titan-mft-server/) - An enterprise-level MFT server solution with high availability and failover capabilities, providing an efficient way to automate and manage large-scale file transfers.
- IBM Sterling Secure File Transfer (https://www.ibm.com/products/secure-file-transfer) - A fast and scalable file transfer platform that offers advanced security features and flexible architecture. It is ideal for businesses that 
require a reliable and secure MFT platform.
- Oracle Managed File Transfer (https://www.oracle.com/middleware/technologies/mft/managed-file-transfer.html) - A comprehensive MFT solution that enables secure file exchange and management, providing a reliable and efficient way for 
businesses to transfer data with ease.
- TIBCO Managed File Transfer (https://www.tibco.com/products/tibco-managed-file-transfer) - A centrally managed MFT platform with powerful automation capabilities and advanced security features, capable of supporting all file transfer 
use cases. It is an ideal choice for businesses that require a comprehensive MFT solution.
⬆ back to top (#contents)
Master Data Management
Master Data Management solutions help organizations create a single, authoritative source of accurate and consistent data across different systems, applications, and departments. These tools provide capabilities for data profiling, 
cleansing, enrichment, and governance, enabling organizations to improve data quality, reduce errors, and increase operational efficiency.
- IBM InfoSphere Master Data Management (https://www.ibm.com/products/ibm-infosphere-master-data-management) - A comprehensive solution for managing master data that provides a single source of truth across your organization.
- Informatica Multidomain MDM (https://www.informatica.com/products/master-data-management/multidomain-mdm.html) - An all-in-one solution that enables you to manage and govern all your master data domains in one place.
- Oracle Enterprise Data Management (https://www.oracle.com/performance-management/enterprise-data-management/) - Helps you adapt and respond to change faster and more effectively by centralizing and managing your master data.
- SAP Master Data Governance (https://www.sap.com/products/master-data-governance.html) - Streamlines and improves the quality and consistency of your data by consolidating and centrally governing your master data lifecycle.
- SAS MDM (https://support.sas.com/en/software/mdm-support.html) - Provides a unified view of your corporate data, integrating information from various sources into one master record for greater accuracy and consistency.
- Software AG OneData for MDM (https://www.softwareag.com/resources/Master-data-management) - Ensures that only reliable, accurate, and approved information flows through your systems, processes, and applications, providing "one version
of the truth."
- Teradata MDM (https://www.teradata.co.uk/Products/Applications/Master-Data-Management) - Establishes an accurate analytical data foundation by using consistent reference data, driving significant ROI.
- TIBCO EBX (https://www.tibco.com/products/tibco-ebx-software) - A single solution to govern, manage, and consume all shared data assets, ensuring greater consistency and accuracy across your organization.
⬆ back to top (#contents)
Messaging
Message brokers are a type of middleware that allows communication between different applications or systems by facilitating the exchange of messages. They can handle different messaging patterns, such as point-to-point, 
publish-subscribe, and request-reply, and provide features such as message transformation, routing, and filtering.
- Apache ActiveMQ (⭐2.2k) (https://github.com/apache/activemq) - An open-source message broker that implements Java Message Service (JMS) and allows for synchronous to asynchronous communication conversion. Offers reliable messaging 
and supports multiple protocols and messaging styles.
- Apache Kafka (⭐27k) (https://github.com/apache/kafka) - A distributed messaging system designed for high-throughput and fault-tolerance. Enables real-time data processing and stream processing applications with its distributed 
architecture and efficient data storage.
- Apache Pulsar (⭐13k) (https://github.com/apache/pulsar) - A distributed pub/sub-messaging system that supports both traditional messaging and streaming use cases. Offers a scalable and flexible architecture and supports multiple 
messaging protocols.
- Apache RocketMQ (⭐20k) (https://github.com/apache/rocketmq) - A fast and reliable distributed messaging platform designed for high volume and low latency messaging scenarios. Offers efficient message storage and retrieval and 
supports various messaging patterns.
- Apache Qpid (⭐55) (https://github.com/apache/qpid-broker-j) - A messaging tool that supports the Advanced Message Queuing Protocol (AMQP) and multiple programming languages and platforms. Offers enterprise-grade messaging 
capabilities with reliable and efficient message delivery.
- BlazingMQ (⭐2.4k) (https://github.com/bloomberg/blazingmq) - A distributed message queueing platform with a focus on efficiency, reliability, and a rich feature set for modern-day workflows.
- Centrifugo (⭐7.8k) (https://github.com/centrifugal/centrifugo) - An open-source, scalable real-time messaging server that allows you to build interactive applications where events are delivered to online users with minimal delay.
- Eclipse Mosquitto (⭐8.3k) (https://github.com/eclipse/mosquitto) - A lightweight open-source message broker that implements the MQTT protocol. Designed for low-power devices and supports message encryption and authentication.
- EMQX (⭐13k) (https://github.com/emqx/emqx) - A high-performance, scalable, and reliable open-source MQTT broker for IoT, IIoT, and connected vehicles.
- IBM MQ (https://www.ibm.com/products/mq) - A robust enterprise-grade messaging system that enables safe and efficient communication between applications. Offers high availability and disaster recovery capabilities and supports 
multiple messaging protocols.
- KubeMQ (https://kubemq.io/) - A Kubernetes-based message broker and queue system designed for scalability, high availability, and security. Offers seamless integration with Kubernetes and supports various messaging patterns.
- NATS (⭐14k) (https://github.com/nats-io/gnatsd) - A lightweight and high-performance messaging system designed for microservices, IoT, and cloud-native systems. Offers efficient and reliable message delivery and supports multiple 
messaging protocols.
- Oracle AQ (https://www.oracle.com/database/technologies/advanced-queuing.html) - A messaging system that provides enterprise message functionality and is widely used within the Oracle database. Offers reliable and efficient message 
delivery and supports multiple messaging styles.
- RabbitMQ (⭐11k) (https://github.com/rabbitmq/rabbitmq-server) - An open-source message broker that implements AMQP and supports multiple messaging protocols and patterns. Offers reliable and efficient message delivery and supports 
clustering and high availability.
- Redpanda (⭐8.7k) (https://github.com/vectorizedio/redpanda) - A streaming platform that is Kafka-compatible and does not require Zookeeper or JVM. Offers high-performance and low-latency messaging and supports stream processing and 
analytics.
- Red Hat AMQ (https://www.redhat.com/en/technologies/jboss-middleware/amq) - A messaging system based on open-source communities like Apache ActiveMQ and Apache Kafka. Offers enterprise-grade messaging capabilities with reliable and 
efficient message delivery.
- TIBCO Enterprise Message Service (https://www.tibco.com/products/tibco-enterprise-message-service) - A standards-based JMS implementation that allows for easy exchange of messages between applications. Offers reliable and efficient 
message delivery and supports various messaging protocols and patterns.
- VerneMQ (⭐3.1k) (https://github.com/vernemq/vernemq) - A high-performance distributed MQTT message broker designed for scalability and reliability. Offers efficient and reliable message delivery and supports multiple messaging 
protocols and patterns.
⬆ back to top (#contents)
RPA
Robotic Process Automation (RPA) solutions are software tools that automate repetitive, rule-based tasks within business processes. RPA bots can perform tasks such as data entry, data extraction, and data processing with accuracy and 
speed, freeing up human workers to focus on more complex tasks.
- Automation Anywhere (https://www.automationanywhere.com/) - An intelligent automation ecosystem that provides Robotic Process Automation (RPA) solutions. This solution is designed to automate business processes and improve operational
efficiency while reducing errors and costs.
- Blue Prism (https://www.blueprism.com/products/intelligent-rpa-automation/) - A no-code automation RPA platform that offers intelligent automation capabilities for businesses. This platform is designed to reduce operational costs and 
improve productivity by automating repetitive digital tasks.
- UiPath (https://www.uipath.com/product) - A platform that provides RPA solutions for automating repetitive digital tasks typically performed by people. This solution offers a comprehensive automation platform that enables businesses 
to automate their processes and increase efficiency.
- WorkFusion (https://www.workfusion.com/platform/) - An automation platform for the enterprise that offers RPA solutions. This platform is designed to automate manual tasks, reduce errors and improve efficiency. It offers a 
comprehensive set of tools for automating workflows and streamlining operations.
⬆ back to top (#contents)
Self-Service Integration
Self-service and citizen integrator tools are designed to enable non-technical users to build integrations without the need for extensive programming knowledge. These tools typically feature drag-and-drop interfaces and pre-built 
connectors for popular applications and services.
- IFTTT (https://ifttt.com/) - A powerful self-service and citizen integrator tool that enables users to create custom workflows by connecting multiple web services with conditional statements, boosting productivity with ease.
- Microsoft Power Automate (https://powerautomate.microsoft.com) - This cloud-based service offers a user-friendly interface to create automated workflows seamlessly, integrating different applications and services with ease, 
simplifying complex tasks.
- Oracle Self-Service Integration (https://docs.oracle.com/en/cloud/paas/self-service-integration-cloud/index.html) - Automate tasks between various cloud applications with ease using Oracle's Self-Service Integration tool, providing a 
seamless and efficient integration process.
- Zapier (https://zapier.com/) - An intuitive automation tool that connects hundreds of web services to create automations between processes with ease, streamlining tasks, and enhancing overall productivity.
⬆ back to top (#contents)
Workflow engine
Software tools that enable the design, execution, and monitoring of complex workflows or business processes. Workflow engines provide a way to automate and streamline business processes, while orchestration engines help to manage the 
interactions between different systems or services.
- Activiti (⭐9.8k) (https://github.com/Activiti/Activiti) - A lightweight and Java-centric open-source engine for executing BPMN (Business Process Model and Notation) workflows.
- Apache Airflow (⭐34k) (https://github.com/apache/airflow) - A platform that allows you to create, schedule, and monitor workflows programmatically, making it easier to manage and automate complex data pipelines.
- Argo Workflows (⭐14k) (https://github.com/argoproj/argo-workflows) - An open-source, container-native workflow engine designed to orchestrate parallel jobs on Kubernetes, making it easier to manage and automate complex workflows in a
cloud-native environment.
- Azkaban (⭐4.3k) (https://github.com/azkaban/azkaban) - A distributed workflow manager that helps solve the problem of Hadoop job dependencies, making it easier to schedule and manage workflows in large-scale data processing 
environments.
- Bonita (⭐145) (https://github.com/bonitasoft/bonita-engine) - An open-source BPMN engine that comes with a designer and optional development environment, making it easier to build and automate complex business processes.
- Cadence (⭐7.7k) (https://github.com/uber/cadence) - A fault-tolerant, stateful code platform that makes it easier to build and manage complex, long-running applications.
- Camunda (⭐3.9k) (https://github.com/camunda/camunda-bpm-platform) - An open-source workflow and decision automation platform that helps you automate business processes and decisions in a flexible and scalable way.
- Conductor (⭐12k) (https://github.com/Netflix/conductor) - A cloud-based orchestration engine designed to run and manage workflows in a microservices architecture.
- Elsa Core (⭐5.7k) (https://github.com/elsa-workflows/elsa-core) - A library that enables workflow execution in any .NET Core application, making it easier to automate business processes in .NET environments.
- Flowable (⭐7.3k) (https://github.com/flowable/flowable-engine) - A set of open-source business process engines that are compact and efficient, making it easier to automate business processes in a scalable and reliable way.
- jBPM (⭐1.5k) (https://github.com/kiegroup/jbpm) - A toolkit for building business applications that helps you automate business processes and decisions, making it easier to manage complex workflows.
- StackStorm (⭐5.8k) (https://github.com/StackStorm/st2) - A robust automation engine that provides sensors, triggers, rules, workflows, and actions to help you automate and orchestrate complex workflows and applications.
- Temporal (⭐9.7k) (https://github.com/temporalio/temporal) - An open-source platform that uses a workflow-as-code approach to make your applications more reliable and scalable. 
⬆ back to top (#contents)
Integration Patterns
Integration patterns provide standardized solutions for common integration problems within an enterprise. Enterprise Integration Patterns (EIP) provide a common language for describing integration problems and solutions, while 
Integration Architecture Patterns address high-level concerns of enterprise architects. Service-Oriented Architecture (SOA) patterns provide guidance for designing and implementing service-oriented architectures, ensuring that services 
are scalable, reusable, and loosely coupled.
Enterprise Integration Patterns
Patterns from a book by Gregor Hohpe and Bobby Woolf.
- Aggregator (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Aggregator.html) - How do we combine the results of individual, but related messages so that they can be processed as a whole? 
- Canonical Data Model (https://www.enterpriseintegrationpatterns.com/patterns/messaging/CanonicalDataModel.html) - How can you minimize dependencies when integrating applications that use different data formats?
- Channel Adapter (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ChannelAdapter.html) - How can you connect an application to the messaging system so that it can send and receive messages?
- Channel Purger (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ChannelPurger.html) - How can you keep 'left-over' messages on a channel from disturbing tests or running systems?
- Claim Check (https://www.enterpriseintegrationpatterns.com/patterns/messaging/StoreInLibrary.html) - How can we reduce the data volume of message sent across the system without sacrificing information content? 
- Command Message (https://www.enterpriseintegrationpatterns.com/patterns/messaging/CommandMessage.html) - How can messaging be used to invoke a procedure in another application? 
- Competing Consumers (https://www.enterpriseintegrationpatterns.com/patterns/messaging/CompetingConsumers.html) - How can a messaging client process multiple messages concurrently?
- Composed Message Processor (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DistributionAggregate.html) - How can you maintain the overall message flow when processing a message consisting of multiple elements, each 
of which may require different processing? 
- Content Enricher (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DataEnricher.html) - How do we communicate with another system if the message originator does not have all the required data items available? 
- Content Filter (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ContentFilter.html) - How do you simplify dealing with a large message, when you are interested only in a few data items? 
- Content-Based Router (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ContentBasedRouter.html) - How do we handle a situation where the implementation of a single logical function (e.g., inventory check) is spread 
across multiple physical systems? 
- Control Bus (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ControlBus.html) - How can we effectively administer a messaging system that is distributed across multiple platforms and a wide geographic area? 
- Correlation Identifier (https://www.enterpriseintegrationpatterns.com/patterns/messaging/CorrelationIdentifier.html) - How does a requestor that has received a reply know which request this is the reply for?
- Datatype Channel (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DatatypeChannel.html) - How can the application send a data item such that the receiver will know how to process it?
- Dead Letter Channel (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DeadLetterChannel.html) - What will the messaging system do with a message it cannot deliver? 
- Detour (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Detour.html) - How can you route a message through intermediate steps to perform validation, testing or debugging functions?
- Document Message (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DocumentMessage.html) - How can messaging be used to transfer data between applications?
- Durable Subscriber (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DurableSubscription.html) - How can a subscriber avoid missing messages while it is not listening for them?
- Dynamic Router (https://www.enterpriseintegrationpatterns.com/patterns/messaging/DynamicRouter.html) - How can you avoid the dependency of the router on all possible destinations while maintaining its efficiency?
- Envelope Wrapper (https://www.enterpriseintegrationpatterns.com/patterns/messaging/EnvelopeWrapper.html) - How can existing systems participate in a messaging exchange that places specific requirements on the message format, such as 
message header fields or encryption? 
- Event Message (https://www.enterpriseintegrationpatterns.com/patterns/messaging/EventMessage.html) - How can messaging be used to transmit events from one application to another?
- Event-Driven Consumer (https://www.enterpriseintegrationpatterns.com/patterns/messaging/EventDrivenConsumer.html) - How can an application automatically consume messages as they become available?
- Format Indicator (https://www.enterpriseintegrationpatterns.com/patterns/messaging/FormatIndicator.html) - How can a messages data format be designed to allow for possible future changes?
- Guaranteed Delivery (https://www.enterpriseintegrationpatterns.com/patterns/messaging/GuaranteedMessaging.html) - How can the sender make sure that a message will be delivered, even if the messaging system fails?
- Idempotent Receiver (https://www.enterpriseintegrationpatterns.com/patterns/messaging/IdempotentReceiver.html) - How can a message receiver deal with duplicate messages?
- Invalid Message Channel (https://www.enterpriseintegrationpatterns.com/patterns/messaging/InvalidMessageChannel.html) - How can a messaging receiver gracefully handle receiving a message that makes no sense?
- Message (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Message.html) - How can two applications connected by a message channel exchange a piece of information?
- Message Dispatcher (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageDispatcher.html) - How can multiple consumers on a single channel coordinate their message processing?
- Message Expiration (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageExpiration.html) - How can a sender indicate when a message should be considered stale and thus shouldnt be processed?
- Message Translator (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageTranslator.html) - How can systems using different data formats communicate with each other using messaging? 
- Message Broker (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageBroker.html) - How can you decouple the destination of a message from the sender and maintain central control over the flow of messages?
- Message Bus (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageBus.html) - What is an architecture that enables separate applications to work together, but in a decoupled fashion such that applications can be 
easily added or removed without affecting the others? 
- Message Channel (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageChannel.html) - How does one application communicate with another using messaging?
- Message Endpoint (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageEndpoint.html) - How does an application connect to a messaging channel to send and receive messages?
- Message Filter (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Filter.html) - How can a component avoid receiving uninteresting messages?
- Message History (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageHistory.html) - How can we effectively analyze and debug the flow of messages in a loosely coupled system? 
- Message Router (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageRouter.html) - How can you decouple individual processing steps so that messages can be passed to different filters depending on a set of 
conditions?
- Message Sequence (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageSequence.html) - How can messaging transmit an arbitrarily large amount of data?
- Message Store (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageStore.html) - How can we report against message information without disturbing the loosely coupled and transient nature of a messaging system? 
- Messaging Bridge (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingBridge.html) - How can multiple messaging systems be connected so that messages available on one are also available on the others?
- Messaging Gateway (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingGateway.html) - How do you encapsulate access to the messaging system from the rest of the application?
- Messaging Mapper (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingMapper.html) - How do you move data between domain objects and the messaging infrastructure while keeping the two independent of each other?
- Normalizer (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Normalizer.html) - How do you process messages that are semantically equivalent, but arrive in a different format?
- Pipes and Filters (https://www.enterpriseintegrationpatterns.com/patterns/messaging/PipesAndFilters.html) - How can we perform complex processing on a message while maintaining independence and flexibility? 
- Point-to-Point Channel (https://www.enterpriseintegrationpatterns.com/patterns/messaging/PointToPointChannel.html) - How can the caller be sure that exactly one receiver will receive the document or perform the call?
- Polling Consumer (https://www.enterpriseintegrationpatterns.com/patterns/messaging/PollingConsumer.html) - How can an application consume a message when the application is ready? 
- Process Manager (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ProcessManager.html) - How do we route a message through multiple processing steps when the required steps may not be known at design-time and may not 
be sequential?
- Publish-Subscribe Channel (https://www.enterpriseintegrationpatterns.com/patterns/messaging/PublishSubscribeChannel.html) - How can the sender broadcast an event to all interested receivers?
- Recipient List (https://www.enterpriseintegrationpatterns.com/patterns/messaging/RecipientList.html) - How do we route a message to a list of dynamically specified recipients?
- Request-Reply (https://www.enterpriseintegrationpatterns.com/patterns/messaging/RequestReply.html) - When an application sends a message, how can it get a response from the receiver?
- Resequencer (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Resequencer.html) - How can we get a stream of related but out-of-sequence messages back into the correct order?
- Return Address (https://www.enterpriseintegrationpatterns.com/patterns/messaging/ReturnAddress.html) - How does a replier know where to send the reply?
- Routing Slip (https://www.enterpriseintegrationpatterns.com/patterns/messaging/RoutingTable.html) - How do we route a message consecutively through a series of processing steps when the sequence of steps is not known at design-time 
and may vary for each message? 
- Scatter-Gather (https://www.enterpriseintegrationpatterns.com/patterns/messaging/BroadcastAggregate.html) - How do you maintain the overall message flow when a message needs to be sent to multiple recipients, each of which may send a 
reply? 
- Selective Consumer (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessageSelector.html) - How can a message consumer select which messages it wishes to receive? 
- Service Activator (https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingAdapter.html) - How can an application design a service to be invoked both via various messaging technologies and via non-messaging 
techniques?
- Smart Proxy (https://www.enterpriseintegrationpatterns.com/patterns/messaging/SmartProxy.html) - How can you track messages on a service that publishes reply messages to the Return Address specified by the requestor?
- Splitter (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Sequencer.html) - How can we process a message if it contains multiple elements, each of which may have to be processed in a different way? 
- Test Message (https://www.enterpriseintegrationpatterns.com/patterns/messaging/TestMessage.html) - What happens, though, if a component is actively processing messages, but garbles outgoing messages due to an internal fault? 
- Transactional Client (https://www.enterpriseintegrationpatterns.com/patterns/messaging/TransactionalClient.html) - How can a client control its transactions with the messaging system? 
- Wire Tap (https://www.enterpriseintegrationpatterns.com/patterns/messaging/WireTap.html) - How do you inspect messages that travel on a point-to-point channel? 
⬆ back to top (#contents)
Integration Architecture Patterns
Design patterns used to connect systems and applications in an efficient and seamless manner.
- API-led Connectivity pattern (https://github.com/chanakaudaya/solution-architecture-patterns/blob/master/vendor-neutral/API-led-Connectivity-Pattern.md) - Use APIs to connect different systems and applications.
- Anti Corruption Layer Pattern (https://github.com/chanakaudaya/solution-architecture-patterns/blob/master/vendor-neutral/Anti-Corruption-Layer-Pattern.md) - Add a layer to isolate and transform data between systems.
- Change Data Capture Pattern (https://github.com/chanakaudaya/solution-architecture-patterns/blob/master/vendor-neutral/Introduction-to-Change-Data-Capture.md) - Capture and propagate changes made to a database or data source in 
real-time.
- Hybrid API Management pattern (https://github.com/chanakaudaya/solution-architecture-patterns/blob/master/vendor-neutral/Hybrid-API-Management-Pattern.md) - Manage APIs that span both cloud and on-premises environments using a central
control plane.
- Hybrid Integration pattern (https://github.com/chanakaudaya/solution-architecture-patterns/blob/master/vendor-neutral/Hybrid-Integration-Pattern.md) - Integrate systems and applications that are deployed both on-premises and in the 
cloud using a combination of integration technologies.
⬆ back to top (#contents)
Microservice API Patterns
MAP (Microservice API Patterns) is a set of proven solutions to common problems encountered when designing, implementing, and maintaining message-based APIs. It focuses on the message representations or payloads exchanged during API 
calls and their impact on the design and runtime qualities of an API. Proper governance of API specifications and implementations is essential for their long-term maintenance.
- Foundation
- **Frontend Integration** (https://microservice-api-patterns.org/patterns/foundation/FrontendIntegration) - How can client-side end-user interfaces that are physically separated from server-side business logic and data storage be popul 
ated and updated with computing results, result sets from searches in data sources, and detailed information about data entities? How can application frontends invoke activities in a backend or upload data to it? 
- **Backend Integration** (https://microservice-api-patterns.org/patterns/foundation/BackendIntegration) - How can distributed applications and their parts, which have been built independently and are deployed separately, exchange data  
and trigger mutual activity while preserving system-internal conceptual integrity without introducing undesired coupling? 
- **Public API** (https://microservice-api-patterns.org/patterns/foundation/PublicAPI) - How can an API be made available to an unlimited and/or unknown number of API clients outside the organization that are globally, nationally, and/o 
r regionally distributed? 
- **Community API** (https://microservice-api-patterns.org/patterns/foundation/CommunityAPI) - How can the visibility of and the access to an API be restricted to a closed user group that does not work for a single organizational unit b 
ut for multiple legal entities (such as companies, nonprofit/nongovernment organizations, and governments)? 
- **Solution-Internal API** (https://microservice-api-patterns.org/patterns/foundation/SolutionInternalAPI) - How can access to and usage of an API be limited to an application, for instance, components in the same or another logical la 
yer and/or physical tier? 
- **API Description** (https://microservice-api-patterns.org/patterns/foundation/APIDescription) - Which knowledge should be shared between an API provider and its clients? How should this knowledge be documented? 
- Responsibility
- Endpoint Roles 
 - **Processing Resource** (https://microservice-api-patterns.org/patterns/responsibility/endpointRoles/ProcessingResource) - How can an API provider allow its clients to trigger an action in it? 
 - **Information Holder Resource** (https://microservice-api-patterns.org/patterns/responsibility/endpointRoles/InformationHolderResource) - How can domain data be exposed in an API, but its implementation still be hidden? How can an 
 API expose data entities so that API clients can access and/or modify these entities concurrently without compromising data integrity and quality? 
- Operation Responsibilities 
 - **State Creation Operation** (https://microservice-api-patterns.org/patterns/responsibility/operationResponsibilities/StateCreationOperation) - How can an API provider allow its clients to report that something has happened that t 
he provider needs to know about, for instance, to trigger instant or later processing? 
 - **Retrieval Operation** (https://microservice-api-patterns.org/patterns/responsibility/operationResponsibilities/RetrievalOperation) - How can information available from a remote party (the API provider, that is) be retrieved to s 
atisfy an information need of an end user or to allow further client-side processing? 
 - **State Transition Operation** (https://microservice-api-patterns.org/patterns/responsibility/operationResponsibilities/StateTransitionOperation) - How can a client initiate a processing action that causes the provider-side applic 
ation state to change? How can API clients and API providers share the responsibilities required to execute and control business processes and their activities? 
 - **Computation Function** (https://microservice-api-patterns.org/patterns/responsibility/operationResponsibilities/ComputationFunction) - How can a client invoke side-effect-free remote processing on the provider side to have a res 
ult calculated from its input? 
- Information Holder Types 
 - **Operational Data Holder** (https://microservice-api-patterns.org/patterns/responsibility/informationHolderEndpointTypes/OperationalDataHolder) - How can an API support clients that want to create, read, update, and/or delete ins 
tances of domain entities that represent operational data: data that is rather short-lived, changes often during daily business operations, and has many outgoing relations? 
 - **Master Data Holder** (https://microservice-api-patterns.org/patterns/responsibility/informationHolderEndpointTypes/MasterDataHolder) - How can I design an API that provides access to master data that lives for a long time, does  
not change frequently, and will be referenced from many clients? 
 - **Reference Data Holder** (https://microservice-api-patterns.org/patterns/responsibility/informationHolderEndpointTypes/ReferenceDataHolder) - How should data that is referenced in many places, lives long, and is immutable for cli 
ents be treated in API endpoints? How can such reference data be used in requests to and responses from Processing Resources or Information Holder Resources? 
 - **Link Lookup Resource** (https://microservice-api-patterns.org/patterns/responsibility/informationHolderEndpointTypes/LinkLookupResource) - How can message representations refer to other, possibly many and frequently changing, AP 
I endpoints and operations without binding the message recipient to the actual addresses of these endpoints? 
 - **Data Transfer Resource** (https://microservice-api-patterns.org/patterns/responsibility/informationHolderEndpointTypes/DataTransferResource) - How can two or more communication participants exchange data without knowing each oth 
er, without being available at the same time, and even if the data has already been sent before its recipients became known? 
- Structure
- Representation Elements 
 - **Atomic Parameter** (https://microservice-api-patterns.org/patterns/structure/representationElements/AtomicParameter) - How can simple, unstructured data (such as a number, a string, a Boolean value, or a block of binary data) be 
 exchanged between API client and API provider? 
 - **Atomic Parameter List** (https://microservice-api-patterns.org/patterns/structure/representationElements/AtomicParameterList) - How can multiple related Atomic Parameters be combined in a representation element so that each of t 
hem stays simple, but their relatedness becomes explicit in the API Description and the runtime message exchanges? 
 - **Parameter Tree** (https://microservice-api-patterns.org/patterns/structure/representationElements/ParameterTree) - How can containment relationships be expressed when defining complex representation elements and exchanging such  
related elements at runtime? 
 - **Parameter Forest** (https://microservice-api-patterns.org/patterns/structure/representationElements/ParameterForest) - How can multiple Parameter Trees be exposed as request or response payload of an API operation? 
- Element Stereotypes 
 - **Data Element** (https://microservice-api-patterns.org/patterns/structure/elementStereotypes/DataElement) - How can domain/application-level information be exchanged between API clients and API providers without exposing provider 
-internal data definitions in the API? How can API client and API provider be decoupled from a data management point of view? 
 - **Metadata Element** (https://microservice-api-patterns.org/patterns/structure/elementStereotypes/MetadataElement) - How can messages be enriched with additional information so that receivers can interpret the message content corr 
ectly, without having to hardcode assumptions about the data semantics? 
 - **Id Element** (https://microservice-api-patterns.org/patterns/structure/elementStereotypes/IdElement) - How can API elements be distinguished from each other at design time and at runtime? When applying domain-driven design, how  
can elements of the Published Language be identified? 
 - **Link Element** (https://microservice-api-patterns.org/patterns/structure/elementStereotypes/LinkElement) - How can API endpoints and operations be referenced in request and response message payloads so that they can be called re 
motely? 
- Special Purpose Representations 
 - **API Key** (https://microservice-api-patterns.org/patterns/structure/specialPurposeRepresentations/APIKey) - How can an API provider identify and authenticate clients and their requests? 
 - **Error Report** (https://microservice-api-patterns.org/patterns/structure/specialPurposeRepresentations/ErrorReport) - How can an API provider inform its clients about communication and processing faults? How can this information 
 be made independent of the underlying communication technologies and platforms (for example, protocol-level headers representing status codes)? 
 - **Context Representation** (https://microservice-api-patterns.org/patterns/structure/specialPurposeRepresentations/ContextRepresentation) - How can API consumers and providers exchange context information without relying on any pa 
rticular remoting protocols? How can identity information and quality properties in a request be made visible to related subsequent ones in conversations? 
- Quality
- Reference Management  
 - **Embedded Entity** (https://microservice-api-patterns.org/patterns/quality/referenceManagement/EmbeddedEntity) - How can one avoid sending multiple messages when their receivers require insights about multiple related information 
 elements? 
 - **Linked Information Holder** (https://microservice-api-patterns.org/patterns/quality/referenceManagement/LinkedInformationHolder) - How can messages be kept small even when an API deals with multiple information elements that ref 
erence each other? 
- Data Transfer Parsimony  
 - **Pagination** (https://microservice-api-patterns.org/patterns/quality/dataTransferParsimony/Pagination) - How can messages be kept small even when an API deals with multiple information elements that reference each other? 
 - **Wish List** (https://microservice-api-patterns.org/patterns/quality/dataTransferParsimony/WishList) - How can an API client inform the API provider at runtime about the data it is interested in? 
 - **Wish Template** (https://microservice-api-patterns.org/patterns/quality/dataTransferParsimony/WishTemplate) - How can an API client inform the API provider about nested data that it is interested in? How can such preferences be  
expressed flexibly and dynamically? 
 - **Conditional Request** (https://microservice-api-patterns.org/patterns/quality/dataTransferParsimony/ConditionalRequest) - How can unnecessary server-side processing and bandwidth usage be avoided when frequently invoking API ope 
rations that return rarely changing data? 
 - **Request Bundle** (https://microservice-api-patterns.org/patterns/quality/dataTransferParsimony/RequestBundle) - How can the number of requests and responses be reduced to increase communication efficiency? 
- Quality Management and Governance  
 - **Pricing Plan** (https://microservice-api-patterns.org/patterns/quality/qualityManagementAndGovernance/PricingPlan) - How can the API provider meter API service consumption and charge for it? 
 - **Rate Limit** (https://microservice-api-patterns.org/patterns/quality/qualityManagementAndGovernance/RateLimit) - How can the API provider prevent API clients from excessive API usage? 
 - **Service Level Agreement** (https://microservice-api-patterns.org/patterns/quality/qualityManagementAndGovernance/ServiceLevelAgreement) - How can an API client learn about the specific quality-of-service characteristics of an AP 
I and its endpoint operations? How can these characteristics, and the consequences of not meeting them, be defined and communicated in a measurable way? 
- Evolution
- **Version Identifier** (https://microservice-api-patterns.org/patterns/evolution/VersionIdentifier) - How can an API provider indicate its current capabilities as well as the existence of possibly incompatible changes to clients in or 
der to prevent malfunctioning of clients due to undiscovered interpretation errors? 
- **Semantic Versioning** (https://microservice-api-patterns.org/patterns/evolution/SemanticVersioning) - How can stakeholders compare API versions to detect immediately whether they are compatible? 
- **Two In Production** (https://microservice-api-patterns.org/patterns/evolution/TwoInProduction) - How can a provider gradually update an API without breaking existing clients but also without having to maintain a large number of API  
versions in production? 
- **Aggressive Obsolescence** (https://microservice-api-patterns.org/patterns/evolution/AggressiveObsolescence) - How can API providers reduce the effort for maintaining an entire API or its parts (such as endpoints, operations, or mess 
age representations) with guaranteed service quality levels? 
- **Experimental Preview** (https://microservice-api-patterns.org/patterns/evolution/ExperimentalPreview) - How can providers make the introduction of a new API, or new API version, less risky for their clients and obtain early adopter  
feedback without having to freeze the API design prematurely? 
- **Limited Lifetime Guarantee** (https://microservice-api-patterns.org/patterns/evolution/LimitedLifetimeGuarantee) - How can a provider let clients know for how long they can rely on the published version of an API? 
- **Eternal Lifetime Guarantee** (https://microservice-api-patterns.org/patterns/evolution/EternalLifetimeGuarantee) - How can a provider support clients that are unable or unwilling to migrate to newer API versions at all? 
⬆ back to top (#contents)
SOA Patterns
SOA patterns are design solutions that provide guidelines and best practices for developing flexible and reusable service-oriented applications. These patterns address various aspects of service-oriented application design, including 
service identification, interaction, composition, and granularity.
- Foundational Inventory Patterns
 - Canonical Protocol (https://patterns.arcitura.com/soa-patterns/design_patterns/canonical_protocol) - Defines a common communication protocol between services to enable interoperability and decoupling.
 - Canonical Schema (https://patterns.arcitura.com/soa-patterns/design_patterns/canonical_schema) - Defines a standard data model and format for exchanging data between services.
 - Domain Inventory (https://patterns.arcitura.com/soa-patterns/design_patterns/domain_inventory) - Identifies and categorizes the types of services within a particular domain.
 - Enterprise Inventory (https://patterns.arcitura.com/soa-patterns/design_patterns/enterprise_inventory) - Identifies and categorizes the types of services within a particular domain.
 - Logic Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/logic_centralization) - Centralizes business logic within a service layer to reduce redundancy and promote consistency.
 - Service Layers (https://patterns.arcitura.com/soa-patterns/design_patterns/service_layers) - Centralizes business logic within a service layer to reduce redundancy and promote consistency.
 - Service Normalization (https://patterns.arcitura.com/soa-patterns/design_patterns/service_normalization) - Centralizes business logic within a service layer to reduce redundancy and promote consistency.
- Logical Inventory Layer Patterns
 - Entity Abstraction (https://patterns.arcitura.com/soa-patterns/design_patterns/entity_abstraction) - Abstracts data entities to simplify data access and reduce coupling.
 - Process Abstraction (https://patterns.arcitura.com/soa-patterns/design_patterns/process_abstraction) - Abstracts processes to improve reusability and maintainability.
 - Utility Abstraction (https://patterns.arcitura.com/soa-patterns/design_patterns/utility_abstraction) - Abstracts common utilities to reduce duplication and promote consistency.
 - Micro Task Abstraction (https://patterns.arcitura.com/soa-patterns/design_patterns/micro_task_abstraction) - Breaks down tasks into smaller, more granular tasks for easier management.
- Inventory Centralization Patterns
 - Policy Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/policy_centralization) - Centralizes policies to reduce duplication and improve consistency.
 - Process Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/process_centralization) - Centralizes processes to improve reusability and maintainability.
 - Rules Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/rules_centralization) - Centralizes business rules to reduce duplication and promote consistency.
 - Schema Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/schema_centralization) - Centralizes data schemas to reduce duplication and improve consistency.
- Inventory Implementation Patterns
 - Canonical Resources (https://patterns.arcitura.com/soa-patterns/design_patterns/canonical_resources) - Defines a standard set of resources for common functionality across services.
 - Cross-Domain Utility Layer (https://patterns.arcitura.com/soa-patterns/design_patterns/cross_domain_utility_layer) - Uses multiple protocols for improved performance and flexibility.
 - Dual Protocols (https://patterns.arcitura.com/soa-patterns/design_patterns/dual_protocols) - Defines a common utility layer across multiple domains.
 - Inventory Endpoint (https://patterns.arcitura.com/soa-patterns/design_patterns/inventory_endpoint) - Defines a standard endpoint for accessing inventory resources.
 - Service Grid (https://patterns.arcitura.com/soa-patterns/design_patterns/service_grid) - Provides a framework for managing and scaling services.
 - State Repository (https://patterns.arcitura.com/soa-patterns/design_patterns/state_repository) - Stores and manages service state information.
 - Stateful Services (https://patterns.arcitura.com/soa-patterns/design_patterns/stateful_services) - Maintains state information across service invocations.
 - Augmented Protocols (https://patterns.arcitura.com/soa-patterns/design_patterns/augmented_protocols) - Enhances protocols with additional features.
- Inventory Governance Patterns
 - Canonical Expression (https://patterns.arcitura.com/soa-patterns/design_patterns/canonical_expression) - Defines a standard expression language for inventory data.
 - Canonical Versioning (https://patterns.arcitura.com/soa-patterns/design_patterns/canonical_versioning) - Defines a standard versioning scheme for inventory resources.
 - Metadata Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/metadata_centralization) - Centralizes metadata to reduce duplication and improve consistency.
- Foundational Service Patterns
 - Agnostic Capability (https://patterns.arcitura.com/soa-patterns/design_patterns/agnostic_capability) - Abstracts service capabilities for improved flexibility.
 - Agnostic Context (https://patterns.arcitura.com/soa-patterns/design_patterns/agnostic_context) - Abstracts service context for improved flexibility.
 - Functional Decomposition (https://patterns.arcitura.com/soa-patterns/design_patterns/functional_decomposition) - Breaks down services into smaller, more manageable components.
 - Non-Agnostic Context (https://patterns.arcitura.com/soa-patterns/design_patterns/non_agnostic_context) - Breaks down services into smaller, more manageable components.
 - Service Encapsulation (https://patterns.arcitura.com/soa-patterns/design_patterns/service_encapsulation) - Encapsulates service functionality for improved maintainability.
- Service Implementation Patterns
 - Partial State Deferral (https://patterns.arcitura.com/soa-patterns/design_patterns/partial_state_deferral) - Encapsulates service functionality for improved maintainability.
 - Partial Validation (https://patterns.arcitura.com/soa-patterns/design_patterns/partial_validation) - Validates only relevant data for improved performance.
 - Redundant Implementation (https://patterns.arcitura.com/soa-patterns/design_patterns/redundant_implementation) - Implements multiple versions of a service for improved flexibility.
 - Service Data Replication (https://patterns.arcitura.com/soa-patterns/design_patterns/service_data_replication) - Replicates data across multiple services for improved performance.
 - Service Façade (https://patterns.arcitura.com/soa-patterns/design_patterns/service_facade) - Provides a simplified interface to a complex service for improved usability.
 - UI Mediator (https://patterns.arcitura.com/soa-patterns/design_patterns/ui_mediator) - Mediates between the user interface and underlying services for improved usability.
 - Reference Data Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/reference_data_centralization) - Centralizes reference data to reduce duplication and improve consistency.
 - Microservice Deployment (https://patterns.arcitura.com/soa-patterns/design_patterns/microservice_deployment) - Deploys services as independent, autonomous units for improved scalability and resilience.
 - Containerization (https://patterns.arcitura.com/soa-patterns/design_patterns/containerization) - How can an environment be provided with maximum support for services with high-performance recovery and scalability requirements?
- Service Security Patterns
 - Exception Shielding (https://patterns.arcitura.com/soa-patterns/design_patterns/exception_shielding) - Protects against security vulnerabilities through proper handling of exceptions.
 - Message Screening (https://patterns.arcitura.com/soa-patterns/design_patterns/message_screening) - Screens messages for malicious content.
 - Service Perimeter Guard (https://patterns.arcitura.com/soa-patterns/design_patterns/service_perimeter_guard) - Guards the service perimeter to prevent unauthorized access.
 - Trusted Subsystem (https://patterns.arcitura.com/soa-patterns/design_patterns/trusted_subsystem) - Establishes trust between subsystems for improved security.
- Service Contract Design Patterns
 - Concurrent Contracts (https://patterns.arcitura.com/soa-patterns/design_patterns/concurrent_contracts) - Allows multiple versions of a service contract to coexist simultaneously.
 - Contract Centralization (https://patterns.arcitura.com/soa-patterns/design_patterns/contract_centralization) - Centralizes service contracts to improve consistency and reduce duplication.
 - Contract Denormalization (https://patterns.arcitura.com/soa-patterns/design_patterns/contract_denormalization) - Centralizes service contracts to improve consistency and reduce duplication.
 - Decoupled Contract (https://patterns.arcitura.com/soa-patterns/design_patterns/decoupled_contract) - Decouples service contracts from their implementation for improved flexibility.
 - Validation Abstraction (https://patterns.arcitura.com/soa-patterns/design_patterns/validation_abstraction) - Abstracts validation logic to improve reusability and maintainability.
- Legacy Encapsulation Patterns
 - File Gateway (https://patterns.arcitura.com/soa-patterns/design_patterns/file_gateway) - Provides a gateway to access legacy file-based systems.
 - Legacy Wrapper (https://patterns.arcitura.com/soa-patterns/design_patterns/legacy_wrapper) - Wraps legacy systems to expose them as services.
 - Multi-Channel Endpoint (https://patterns.arcitura.com/soa-patterns/design_patterns/multi_channel_endpoint) - Provides multiple communication channels to access legacy systems.
- Service Governance Patterns
 - Compatible Change (https://patterns.arcitura.com/soa-patterns/design_patterns/compatible_change) - Enables changes to a service without breaking existing clients.
 - Decomposed Capability (https://patterns.arcitura.com/soa-patterns/design_patterns/decomposed_capability) - Breaks down a service capability into smaller, more manageable pieces.
 - Distributed Capability (https://patterns.arcitura.com/soa-patterns/design_patterns/distributed_capability) - Breaks down a service capability into smaller, more manageable pieces.
 - Proxy Capability (https://patterns.arcitura.com/soa-patterns/design_patterns/proxy_capability) - Provides a proxy to a remote service capability to improve performance and reduce network overhead.
 - Service Decomposition (https://patterns.arcitura.com/soa-patterns/design_patterns/service_decomposition) - Breaks down a monolithic service into smaller, more manageable pieces.
 - Service Refactoring (https://patterns.arcitura.com/soa-patterns/design_patterns/service_refactoring) - Refactors a service to improve its design and performance.
 - Termination Notification (https://patterns.arcitura.com/soa-patterns/design_patterns/termination_notification) - Notifies clients of a service's termination.
 - Version Identification (https://patterns.arcitura.com/soa-patterns/design_patterns/version_identification) - Identifies the version of a service. 
- Capability Composition Patterns
 - Capability Composition (https://patterns.arcitura.com/soa-patterns/design_patterns/capability_composition) - Combines multiple service capabilities to create a new capability.
 - Capability Recomposition (https://patterns.arcitura.com/soa-patterns/design_patterns/capability_recomposition) - Recombines existing service capabilities to create a new capability.
- Service Messaging Patterns
 - Asynchronous Queuing (https://patterns.arcitura.com/soa-patterns/design_patterns/asynchronous_queuing) - Uses a message queue to decouple services and improve scalability and reliability.
 - Event-Driven Messaging (https://patterns.arcitura.com/soa-patterns/design_patterns/event_driven_messaging) - Uses events to trigger service invocations and reduce coupling.
 - Intermediate Routing (https://patterns.arcitura.com/soa-patterns/design_patterns/intermediate_routing) - Uses intermediate routing nodes to improve performance and flexibility.
 - Messaging Metadata (https://patterns.arcitura.com/soa-patterns/design_patterns/messaging_metadata) - Uses metadata to describe and manage service messages.
 - Reliable Messaging (https://patterns.arcitura.com/soa-patterns/design_patterns/reliable_messaging) - Ensures message delivery and reliability in a distributed environment.
 - Service Agent (https://patterns.arcitura.com/soa-patterns/design_patterns/service_agent) - Acts as a proxy for a remote service to improve performance and reduce network overhead.
 - Service Callback (https://patterns.arcitura.com/soa-patterns/design_patterns/service_callback) - Uses callbacks to communicate between services.
 - Service Instance Routing (https://patterns.arcitura.com/soa-patterns/design_patterns/service_instance_routing) - Routes messages based on the service instance to improve performance and scalability.
 - Service Messaging (https://patterns.arcitura.com/soa-patterns/design_patterns/service_messaging) - Describes the communication between services.
 - State Messaging (https://patterns.arcitura.com/soa-patterns/design_patterns/state_messaging) - Uses messages to manage state information in a distributed environment.
- Composition Implementation Patterns
 - Agnostic Sub-Controller (https://patterns.arcitura.com/soa-patterns/design_patterns/agnostic_sub_controller) - Separates sub-controllers from the main controller to improve reusability and maintainability.
 - Atomic Service Transaction (https://patterns.arcitura.com/soa-patterns/design_patterns/atomic_service_transaction) - Uses transactions to ensure atomicity and consistency across multiple service invocations.
 - Compensating Service Transaction (https://patterns.arcitura.com/soa-patterns/design_patterns/compensating_service_transaction) - Reverses the effects of a failed transaction.
 - Composition Autonomy (https://patterns.arcitura.com/soa-patterns/design_patterns/composition_autonomy) - Enables services to act autonomously within a composition.
- Service Interaction Security Patterns
 - Brokered Authentication (https://patterns.arcitura.com/soa-patterns/design_patterns/brokered_authentication) - Authenticates clients through a broker.
 - Data Confidentiality (https://patterns.arcitura.com/soa-patterns/design_patterns/data_confidentiality) - Ensures data confidentiality in a distributed environment.
 - Data Origin Authentication (https://patterns.arcitura.com/soa-patterns/design_patterns/data_origin_authentication) - Authenticates the origin of a message.
 - Direct Authentication (https://patterns.arcitura.com/soa-patterns/design_patterns/direct_authentication) - Authenticates clients directly.
- Transformation Patterns
 - Data Format Transformation (https://patterns.arcitura.com/soa-patterns/design_patterns/data_format_transformation) - Transforms data formats to enable interoperability.
 - Data Model Transformation (https://patterns.arcitura.com/soa-patterns/design_patterns/data_model_transformation) - Transforms data models to enable interoperability.
 - Protocol Bridging (https://patterns.arcitura.com/soa-patterns/design_patterns/protocol_bridging) - Bridges between different protocols to enable interoperability.
- REST-inspired Patterns
 - Entity Linking (https://patterns.arcitura.com/soa-patterns/design_patterns/entity_linking) - Links related resources to enable navigation and discovery.
 - Lightweight Endpoint (https://patterns.arcitura.com/soa-patterns/design_patterns/lightweight_endpoint) - Provides a lightweight endpoint for resource access.
 - Reusable Contract (https://patterns.arcitura.com/soa-patterns/design_patterns/reusable_contract) - Reuses common contracts to improve consistency and reduce duplication.
 - Content Negotiation (https://patterns.arcitura.com/soa-patterns/design_patterns/content_negotiation) - Negotiates the content format between clients and servers.
 - Endpoint Redirection (https://patterns.arcitura.com/soa-patterns/design_patterns/endpoint_redirection) - Redirects clients to alternative endpoints.
 - Idempotent Capability (https://patterns.arcitura.com/soa-patterns/design_patterns/idempotent_capability) - Ensures that the same action can be performed multiple times without changing the system state.
⬆ back to top (#contents)
Resources
Some useful specifications, standards, articles and documentation.
API Specification
- API Blueprint (⭐8.6k) (https://github.com/apiaryio/api-blueprint) - A powerful high-level language for designing and documenting APIs that allows software engineers to easily collaborate and create efficient APIs.
- AsyncAPI (⭐3.8k) (https://github.com/asyncapi/spec) - An essential tool for developing Event-Driven Architectures (EDA) and enables engineers to build a better tooling ecosystem.
- GraphQL (⭐14k) (https://github.com/graphql/graphql-spec) - A sophisticated query language and runtime for building efficient APIs that empowers engineers to retrieve data from existing systems with ease.
- JSON:API (⭐7.3k) (https://github.com/json-api/json-api) - A standardized specification for building APIs that simplifies the representation of resources, relationships, and metadata, making it easier for software engineers to create 
efficient APIs.
- OpenAPI (ex.Swagger) (⭐28k) (https://github.com/OAI/OpenAPI-Specification) - A language-agnostic specification for creating RESTful APIs that enables both humans and machines to understand the capabilities of a service without the 
need for source code or documentation.
- RAML (⭐3.8k) (https://github.com/raml-org/raml-spec) - A RESTful API Modeling Language that allows software engineers to design and create efficient APIs by modeling resources, endpoints, and interactions.
- WSDL (http://www.w3.org/TR/wsdl20) - A powerful XML-based interface description language for SOAP-based services that enables software engineers to describe the functionality of a web service and automate the creation of client code.
⬆ back to top (#contents)
Articles
- API-Security-Checklist (⭐21k) (https://github.com/shieldfy/API-Security-Checklist) - Best practices about REST API security.
- Architectural Styles and
the Design of Network-based Software Architectures (https://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm) - Roy Fielding's dissertation defining REST.
- Enterprise Integration Using REST (http://martinfowler.com/articles/enterpriseREST.html) - Discusses the constraints and flexibility that you have with nonpublic APIs, and lessons learned from doing large scale RESTful integration 
across multiple teams.
- Richardson Maturity Model (http://martinfowler.com/articles/richardsonMaturityModel.html) - Explained by Martin Fowler, originally presented by Leonard Richardson.
- Web API Design: Crafting interfaces that developers love (https://pages.apigee.com/rs/apigee/images/api-design-ebook-2012-03.pdf) - Creating Web APIs that are consistent, intuitive, and user-friendly for developers.
⬆ back to top (#contents)
Certifications
 
- API Designer (https://apiacademy.learnupon.com/) - Validate your understanding of API design basics and best practices.
- API Product Manager (https://apiacademy.co/2020/05/virtual-api-academy-workshop/) - Demonstrate your proficiency in managing APIs as products.
- API Security Architect (https://apiacademy.co/api-certification/) - Validate your expertise in securing APIs using modern architectures.
 
 
- API Documentation Best Practices (https://www.apisecuniversity.com/courses/api-documentation-best-practices) - The 2-hour course covers everything you need to know to create, automate, and publish API documentation your developers, 
partners and users will love. You wll also learn why API documentation is the foundation for strong governance, effective API security, and achieving your API business goals.
- API Penetration Testing (https://www.apisecuniversity.com/courses/api-penetration-testing) - The API Penetration Testing course covers all the key topics to become an APIsec professional. This hands-on course includes over 12 hours of
live instruction and provides detailed labs on API hacking techniques and how to uncover vulnerabilities.
- API Security for PCI Compliance (https://www.apisecuniversity.com/courses/api-security-for-pci-compliance) - This 60-minute course examines the new PCI DSS 4.0 requirements and details the API security obligations for compliance. DSS 
4.0 introduces API security concerns for the time ever - enroll to understand what the implications are for your organization.
- API Security Fundamentals (https://www.apisecuniversity.com/courses/api-security-fundamentals) - The 90-minute course covers the core threats to APIs and how to prevent breaches. Learn the OWASP API Security Top 10, examine real-world
API attacks, and understand the 3 Pillars of API Security.
- Certified API Security Analyst (https://www.apisecuniversity.com/courses/certified-api-security-analyst-exam) - The CASA exam is designed to test your expertise in API security threats, risks, and best practices. Students are expected
to have completed the OWASP API Security and Beyond! course before attempting to earn the CASA certification.
- OWASP API Security Top 10 (https://www.apisecuniversity.com/courses/owasp-api-security-top-10-and-beyond) - The 90-minute course provides a deep-dive into the 2023 edition of the OWASP API Security Top 10 - and covers key concepts 
that didn't make it into the Top 10.
- Securing API Servers (https://www.apisecuniversity.com/courses/securing-api-servers) - Learn key concepts for keeping API servers secure - from CORS to error handling to rate limiting and more.
 
 
- Associate Administrator Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIKWA2&ltui__urlRedirect=learning-plan-detail-standard) - Validates an individual's foundational 
knowledge and skills in managing and administering the Boomi platform, focusing on platform monitoring, troubleshooting, and security.
- Associate Developer Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIeWAM&ltui__urlRedirect=learning-plan-detail-standard) - Demonstrates a candidate's basic understanding of 
building and deploying integration processes using the Boomi platform, including design patterns, deployment, and error handling.
- Associate EDI for X12 Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIFWA2&ltui__urlRedirect=learning-plan-detail-standard) - Validates an individual's proficiency in using 
Boomi to design, develop, and manage Electronic Data Interchange (EDI) integrations with the X12 standard, covering essential concepts like EDI document structure and trading partner management.
- Associate Flow Essentials Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIZWA2&ltui__urlRedirect=learning-plan-detail-standard) - Showcases a candidate's knowledge of creating
and managing business applications using Boomi Flow, with emphasis on workflow design, user interfaces, and data integration.
- Associate Master Data Hub Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIPWA2&ltui__urlRedirect=learning-plan-detail-standard) - Highlights a candidate's understanding of 
using the Boomi Master Data Hub to ensure data quality and consistency across systems, focusing on data modeling, governance, and synchronization.
- Development and Application Architecture Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OJOWA2&ltui__urlRedirect=learning-plan-detail-standard) - Confirms an individual's 
expertise in designing and implementing complex integration solutions and application architectures on the Boomi platform, including best practices and performance optimization.
- Professional API Design Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OKzWAM&ltui__urlRedirect=learning-plan-detail-standard) - Demonstrates a candidate's ability to design, 
develop, and manage APIs using Boomi, including RESTful API principles, API security, and versioning.
- Professional API Management Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIyWAM&ltui__urlRedirect=learning-plan-detail-standard) - Validates an individual's expertise in 
managing the full lifecycle of APIs using the Boomi platform, including API deployment, monitoring, and analytics.
- Professional Developer Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OJrWAM&ltui__urlRedirect=learning-plan-detail-standard) - Recognizes a candidate's in-depth knowledge and 
skills in developing, deploying, and managing integration processes using Boomi, with emphasis on advanced data transformation and error handling techniques.
- Professional Flow Developer Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIUWA2&ltui__urlRedirect=learning-plan-detail-standard) - Showcases an individual's advanced 
capabilities in designing, developing, and managing business applications using Boomi Flow, including complex workflow design, custom UI components, and integration with external systems.
- Professional Linux Operational Administrator Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OI5WAM&ltui__urlRedirect=learning-plan-detail-standard) - Confirms a candidate's 
proficiency in managing and administering Boomi on Linux systems, covering topics such as system installation, configuration, security, and performance optimization.
- Professional Windows Operational Administrator Certification (https://community.boomi.com/s/learning-plan-detail-standard?ltui__urlRecordId=aOM6S0000008OIAWA2&ltui__urlRedirect=learning-plan-detail-standard) - Validates an 
individual's expertise in managing and administering Boomi on Windows systems, focusing on system installation, configuration, security, and performance optimization.
 
 
- IBM Certified Solution Developer – App Connect Enterprise V11 (https://www.ibm.com/training/certification/C0003107#exam) - Validate your intermediate-level knowledge and experience to develop, deploy, tune, and support 
platform-independent message flow applications using IBM App Connect V11.0.
- IBM Certified Solution Implementer – API Connect v10.0.3 (https://www.ibm.com/training/certification/C0002604#exam) - Demonstrate your intermediate-level knowledge and skills to develop, publish, configure, and manage APIs using IBM 
API Connect v10.0.3.
- Event-native API Management Foundations (https://gravitee.getlearnworlds.com/course/gravitee-event-native-api-management-foundations) - Basics of Event-native API Management.
- Event-native API Management Professional (https://gravitee.getlearnworlds.com/course/gravitee-enap-certification) - Focuses on some more advanced API Management concepts, plus foundational knowledge around how to use Gravitee API 
Management.
 
 
- Kong Gateway Certified Associate (https://konghq.com/academy/exam-preparation) - Validate your entry-level knowledge and skills on Kong Gateway for developers, DevOps, and architects.
 
- MuleSoft Certified Developer - Level 1 (https://training.mulesoft.com/certification/developer-mule4-level1) - Validate your knowledge and skills to design, build, test and debug, deploy, and manage basic APIs and integrations using 
MuleSoft.
- MuleSoft Certified Developer - Level 2 (https://training.mulesoft.com/certification/developer-mule4-level2) - Validate your ability to work on production-ready Mule applications that address and balance critical non-functional 
requirements including monitoring, performance, maintainability, reliability, and security.
- MuleSoft Certified Integration Architect - Level 1 (https://training.mulesoft.com/certification/architect-integration-level1) - Validate your knowledge and skills to translate functional and non-functional requirements into 
integration interfaces and implementations.
- MuleSoft Certified Platform Architect - Level 1 (https://training.mulesoft.com/certification/architect-platform-level1) - Validate your knowledge and skills to direct the emergence of an effective application network out of individual
integration solutions following API-led connectivity across an organization using Anypoint Platform.
- Oracle Business Process Management Suite 12c Certified Implementation Specialist (https://education.oracle.com/oracle-business-process-management-suite-12c-essentials/pexam_1Z0-435) - Validate your expertise in implementing Oracle BPM
Suite 12c solution.
- Oracle Cloud Platform Application Integration 2022 Certified Professional (https://education.oracle.com/oracle-cloud-platform-application-integration-2022-certified-professional/trackp_OCPAI2022CP) - Validate your understanding of 
Oracle Application Integration to implement these Cloud services.
- Oracle Data Integrator 12c Certified Implementation Specialist (https://education.oracle.com/oracle-data-integrator-12c-certified-implementation-specialist/trackp_379) - Validate your expertise in selling or implementing Oracle Data 
Integration 12c solutions.
- Oracle SOA Suite 12c Certified Implementation Specialist (https://education.oracle.com/oracle-soa-suite-12c-essentials/pexam_1Z0-434) - Validate your expertise in implementing solutions based on Oracle SOA Suite 12c.
 
- Red Hat Certified Specialist in API Management (https://www.redhat.com/en/services/certification/red-hat-certified-specialist-api-management) - Validates the ability to create and maintain enterprise APIs using the Red Hat 3scale API 
Management platform.
- Red Hat Certified Specialist in Business Rules (https://www.redhat.com/en/services/certification/rhcs-business-rules) - Checks the knowledge, skills, and abilities needed to perform tasks involving the implementation and management of
business logic using the Red Hat JBoss BRMS.
- Red Hat Certified Specialist in Cloud-native Integration (https://www.redhat.com/en/services/certification/rhcs-cloud-native-integration) - Validates the ability to create and maintain enterprise integration services based on Red Hat 
Fuse, Camel, and APIs.
- Red Hat Certified Specialist in Event-Driven Development with Kafka (https://www.redhat.com/en/services/certification/red-hat-certified-specialist-event-driven-development-kafka) - Validates the ability to develop applications using 
Apache Kafka and Apache Kafka Streams.
 
 
- SAP Certified Development Associate - SAP Integration Suite (https://training.sap.com/certification/c_cpi_15-sap-certified-development-associate---sap-integration-suite-g/) - Validates that the candidate possesses the fundamental and 
core knowledge required of the SAP Integration Suite profile.
 
- SnapLogic Administrator Certification (https://learn.snaplogic.com/snaplogic-administrator-certification) - Assesses your ability to handle administrative tasks for SnapLogic instances.
- SnapLogic Architect Certification (https://learn.snaplogic.com/snaplogic-architect-certification) - Evaluates your knowledge of integration reference architectures and key strategies for the SnapLogic platform, covering topics like 
SnapLogic Architecture, Snaplex Requirements, Pipeline Lifecycle Management, Advanced Data Transformations, API Management, Resumable Pipelines, and Best Practices.
- SnapLogic Certified Enterprise Automation Professional (https://learn.snaplogic.com/snaplogic-certified-automation-professional) - An advanced certification covering topics like SnapLogic platform, asset management, workflows, 
expression language, tasks, pipeline modularization, migration, and user assistance videos for various endpoints.
- SnapLogic Developer Certification (https://learn.snaplogic.com/snaplogic-developer-certification) - Testing your expertise in using the SnapLogic SDK, implementing different parts of Snap functionality, and building custom Snaps.
- SnapLogic Integrator Certification (https://learn.snaplogic.com/snaplogic-integrator-certification-1) - Focuses on topics such as beginner training, ultra tasks, pipeline migration, and user assistance videos covering various 
integration endpoints.
- TIBCO BusinessWorks Associate (https://www.tibco.com/services/education/certification/tibco-businessworks-associate-certification-exam) - Checks the understanding of Business Studio and TIBCO Cloud Integration, designing application 
components (modules, WSDL, REST API), developing integration applications, and testing, deploying, and managing applications.
- TIBCO BusinessWorks Certified Professional (https://www.tibco.com/services/education/certification/tibco-businessworks-6-certification-exam) - Validates the ability to design, develop, deploy, monitor, and manage TIBCO BusinessWorks 
applications of average complexity with minimal supervision.
- TIBCO BusinessWorks Container Edition Certified Professional (https://www.tibco.com/services/education/certification/tibco-businessworks-container-edition-certification-exam) - Validates the ability to develop, deploy, and manage 
TIBCO BusinessWorks Container Edition applications of average complexity with minimal supervision.
- TIBCO BPM Enterprise Associate (https://www.tibco.com/services/education/certification/tibco-bpm-enterprise-associate-certification-exam) - Checks the understanding of TIBCO BPM's features and capabilities, developing and managing 
business processes, and deploying and testing process applications.
- TIBCO BPM Enterprise Certified Professional (https://www.tibco.com/services/education/certification/tibco-bpm-enterprise-5-certification-exam) - Validates the ability to design, develop, deploy, and manage business processes using 
TIBCO BPM Enterprise Suite.
- TIBCO Cloud Associate Certification (https://www.tibco.com/services/education/certification/tibco-cloud-associate-certification-exam) - Validates the skills and knowledge required to work with TIBCO Cloud, including its key components
and features.
- TIBCO Cloud API Management Associate (https://www.tibco.com/services/education/certification/tibco-mashery-associate-certification-exam) - Covers topics such as API definition creation and testing, API key authentication, and using 
the Developer Portal and I/O docs.
- TIBCO Cloud API Management Certified Professional (https://www.tibco.com/services/education/certification/tibco-cloud-api-management-professional-certification-exam) - Validates the ability to implement TIBCO Cloud Mesh, OAuth-based 
security, and manage SOAP services.
- TIBCO Cloud Integration Associate (https://www.tibco.com/services/education/certification/tibco-cloud-integration-associate-certification-exam) - Validates the skills and knowledge required to work with TIBCO Cloud Integration, 
including its Connect, Develop, and Integrate capabilities.
- TIBCO Cloud Integration - Connect Associate (https://www.tibco.com/services/education/certification/tibco-cloud-integration-connect-associate-certification-exam) - Checks the usage of Connect capability of TIBCO Cloud Integration, 
installing On-Premise Agent, creating connections and integration apps, and configuring flows.
- TIBCO Cloud Integration - Connect Certified Professional (https://www.tibco.com/services/education/certification/tibco-cloud-integration-connect-certified-professional-exam) - Checks the creation and management of connections, 
ensuring connection security, and troubleshooting issues related to connections in TIBCO Cloud Integration.
- TIBCO Cloud Integration Certified Professional (https://www.tibco.com/services/education/certification/tibco-cloud-integration-certified-professional-exam) - Checks the knowledge about capabilities and benefits, integrating, 
developing, and connecting applications, creating APIs using the API Modeler and Mock functionality, and more.
- TIBCO Messaging Associate (https://www.tibco.com/services/education/certification/tibco-messaging-associate-certification-exam) - Covers topics such as TIBCO Enterprise Message Service (EMS), TIBCO FTL, TIBCO eFTL, as well as other 
messaging technologies such as Apache Kafka, Apache Pulsar, and Eclipse Mosquitto.
- TIBCO Messaging Certified Professional (https://www.tibco.com/services/education/certification/tibco-messaging-certified-professional-exam) - Validates the skills and knowledge required to work with TIBCO Messaging and its components,
including TIBCO Enterprise Message Service (EMS), TIBCO FTL, and TIBCO eFTL.
 
- Workato Automation Pro I (https://academy.workato.com/enterprise-automation-i-exam) - Fundamentals of business automation processes.
- Workato Automation Pro II (https://academy.workato.com/enterprise-automation-ii-exam) - Advanced and practical approaches to automation.
- Workato Automation Pro III (https://academy.workato.com/automation-pro-iii-exam) - In-depth series of badged modules for maximizing Workato's potential.
- WSO2 Certified API Manager Developer - V3 (https://wso2.com/training/certification/certified-api-manager-developer/) - Assesses your expertise in designing, developing, and publishing APIs using WSO2 API Manager V3, including API 
lifecycle management, access control, and API documentation.
- WSO2 Certified API Manager Developer - V4 - Micro Integrator Profile (https://wso2.com/training/certification/certified-api-manager-developer-v4-micro-integrator-profile/) - Validates your expertise in designing, developing, and 
publishing APIs using the Micro Integrator profile of WSO2 API Manager V4. It covers API lifecycle management, access control, and API documentation within the Micro Integrator context.
- WSO2 Certified API Manager Expert - V3 (https://wso2.com/training/certification/certified-api-manager-expert/) - Confirms your advanced skills and knowledge in using WSO2 API Manager V3 for API management, including API creation, 
publishing, security, policy implementation, and analytics.
- WSO2 Certified API Manager Expert - V4 - API Management Profile (https://wso2.com/training/certification/api-manager-expert-v4-api-management-profile/) - Demonstrates your proficiency in using WSO2 API Manager V4 for API management 
tasks, such as creating, publishing, and securing APIs, as well as implementing policies and analytics.
- WSO2 Certified Enterprise Integrator Developer - V6 (https://wso2.com/training/certification/certified-enterprise-integrator6-developer/) - Validates your ability to develop, deploy, and manage integration solutions using WSO2 
Enterprise Integrator V6, including knowledge of its components, such as the ESB profile, Message Broker, and Business Process Server.
- WSO2 Certified Enterprise Integrator Developer - V7 - Micro Integrator (https://wso2.com/training/certification/certified-enterprise-integrator-developer-micro-integrator/) - Validates your knowledge and skills in using the Micro 
Integrator profile of WSO2 Enterprise Integrator V7 to develop, deploy, and manage integration solutions.
- WSO2 Certified Enterprise Integrator Developer - V7 - Streaming Integrator (https://wso2.com/training/certification/certified-enterprise-integrator-developer-streaming-integrator/) - Demonstrates your expertise in using the Streaming 
Integrator profile of WSO2 Enterprise Integrator V7 to develop, deploy, and manage real-time data integration and streaming analytics solutions.
- WSO2 Certified Enterprise Integrator Expert - V6 (https://wso2.com/training/certification/certified-enterprise-integrator6-expert/) - Tests your in-depth knowledge and skills in using WSO2 Enterprise Integrator V6 for complex 
integration scenarios, including best practices, troubleshooting, and performance tuning.
- WSO2 Certified Solutions Architect Associate (https://wso2.com/training/certification/certified-solutions-architect-associate/) - Assesses your understanding of the fundamental concepts and principles of WSO2 product architecture, as 
well as your ability to design and implement solutions using WSO2 technologies.
⬆ back to top (#contents)
Connectors
- JCA (https://projects.eclipse.org/projects/ee4j.jca) - Defines a standard architecture for Jakarta EE application components to connect to Enterprise Information Systems. Formerly Java EE Connector Architecture and J2EE Connector 
Architecture.
- Kafka Connect (https://kafka.apache.org/documentation/#connect) - A tool for scalably and reliably streaming data between Apache Kafka and other systems.
⬆ back to top (#contents)
Data Formats
- Apache Avro (⭐2.7k) (https://github.com/apache/avro) - Data serialization system that provides compact, fast, and efficient serialization of structured data. It supports schema evolution, allows for efficient data compression, and is
designed to work well with big data processing frameworks.
- BSON (https://bsonspec.org/) - Binary-encoded serialization format for JSON-like documents that is designed to be lightweight and efficient. It supports rich data types and is widely used in NoSQL databases, such as MongoDB.
- CSV (https://datatracker.ietf.org/doc/html/rfc4180) - A simple and widely used data format that stores tabular data in plain text. It is easy to read and write, and can be processed by most programming languages.
- JSON (https://datatracker.ietf.org/doc/html/rfc8259) - A lightweight and easy-to-read data format that is widely used for data exchange. It supports a wide range of data types and is compatible with many programming languages.
- NDJSON (⭐632) (https://github.com/ndjson/ndjson-spec) - A standard for delimiting JSON objects in stream protocols. It allows for efficient processing of large JSON datasets and is widely used in big data processing.
- Protocol Buffers (⭐63k) (https://github.com/protocolbuffers/protobuf) - A language-neutral and platform-neutral serialization mechanism that is designed to be highly efficient and extensible. It supports rich data types and is widely
used in distributed systems, such as gRPC and Apache Kafka.
- XML (https://www.w3.org/TR/xml11/) - A flexible and widely used markup language that is used for storing and exchanging structured data. It supports rich data types and is compatible with many programming languages.
- YAML (⭐309) (https://github.com/yaml/yaml-spec) - A human-friendly and easy-to-read data serialization format that is widely used for configuration files and data exchange. It supports rich data types and is compatible with most 
programming languages.
⬆ back to top (#contents)
Integration Styles
- File Transfer (https://www.enterpriseintegrationpatterns.com/patterns/messaging/FileTransferIntegration.html) - Data is exchanged through file exchange between applications.
- Messaging (https://www.enterpriseintegrationpatterns.com/patterns/messaging/Messaging.html) - Applications exchange messages using a messaging infrastructure.
- Remote Procedure Invocation (https://www.enterpriseintegrationpatterns.com/patterns/messaging/EncapsulatedSynchronousIntegration.html) - Applications call functions or procedures on a remote server over a network.
- Shared Database (https://www.enterpriseintegrationpatterns.com/patterns/messaging/SharedDataBaseIntegration.html) - Multiple applications access and manipulate the same data through a common database.
⬆ back to top (#contents)
Market Analysis
- API Management
 - Gartner Critical Capabilities for Full Life Cycle API Management (https://www.gartner.com/doc/code/468184)
 - Gartner Magic Quadrant for Full Life Cycle API Management (https://www.gartner.com/doc/code/464116)
 - The Forrester Wave: API Management Solutions (https://www.forrester.com/go?objectid=RES159081)
- BPM
 - Gartner Critical Capabilities for Intelligent Business Process Management Suites (https://www.gartner.com/doc/code/292486)
 - Gartner Magic Quadrant for Intelligent Business Process Management Suites (https://www.gartner.com/doc/code/345694)
- ETL
 - Gartner Critical Capabilities for Data Integration Tools (https://www.gartner.com/doc/code/464068)
 - Gartner Magic Quadrant for Data Integration Tools (https://www.gartner.com/doc/code/450251)
- iPaaS
 - Gartner Critical Capabilities for Enterprise Integration Platform as a Service (https://www.gartner.com/doc/code/434187)
 - Gartner Magic Quadrant for Enterprise Integration Platform as a Service (https://www.gartner.com/doc/code/397953)
 - The Forrester Wave: Enterprise iPaaS (https://www.forrester.com/report/the-forrester-wave-tm-enterprise-ipaas-q4-2021/RES176201)
- RPA
 - Gartner Critical Capabilities for Robotic Process Automation (https://www.gartner.com/doc/code/465756)
 - Gartner Magic Quadrant for Robotic Process Automation (https://www.gartner.com/doc/code/441474)
 - The Forrester Wave: Robotic Process Automation (https://www.forrester.com/go?objectid=RES161538)
⬆ back to top (#contents)
Protocols
- AMQP 0-9-1 (https://www.rabbitmq.com/resources/specs/amqp0-9-1.pdf) - A message queuing protocol that enables the exchange of messages between applications or systems. AMQP 0-9-1 provides reliability, security, and flexibility to 
handle complex messaging scenarios.
- AMQP 1.0 (http://docs.oasis-open.org/amqp/core/v1.0/os/amqp-core-overview-v1.0-os.html) - A widely accepted message queuing protocol that provides reliable, interoperable, and efficient messaging between systems. AMQP 1.0 supports a 
broad range of messaging scenarios and is ideal for complex enterprise-level applications.
- CoAP (http://coap.technology/) - A specialized application protocol designed for constrained devices in the Internet of Things (IoT) ecosystem. CoAP offers a lightweight, low-overhead communication mechanism to support 
resource-constrained devices.
- HTTP (https://httpwg.org/specs/) - A widely used protocol that facilitates communication between web servers and clients. HTTP enables the transfer of data over the internet, making it possible for web applications to function 
seamlessly.
- JSON-RPC (https://www.jsonrpc.org/specification) - A simple and lightweight remote procedure call protocol that enables communication between systems using JSON data. JSON-RPC offers stateless communication and is suitable for 
resource-constrained devices.
- MQTT (https://mqtt.org/mqtt-specification/) - A lightweight and efficient publish-subscribe protocol that supports messaging between devices. MQTT enables low-overhead communication and is ideal for IoT and mobile applications.
- OpenMessaging (⭐286) (https://github.com/openmessaging/specification) - A cloud native, vendor-neutral open specification for distributed messaging.
- SOAP (https://www.w3.org/TR/soap/) - A messaging protocol that uses XML to enable communication between systems. SOAP supports a wide range of messaging scenarios, including distributed computing and enterprise applications.
- STOMP (https://stomp.github.io/) - A messaging protocol that offers simple, text-oriented communication between systems. STOMP is ideal for low-latency, high-performance messaging scenarios.
⬆ back to top (#contents)
Standard APIs
- JDBC (https://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) - A Java-based API that provides universal data access to relational databases. JDBC offers a consistent and efficient way to access and manipulate data, making it a 
popular choice among developers.
- JMS (https://javaee.github.io/jms-spec/) - A messaging API that enables Java applications to send and receive messages. JMS supports reliable messaging and is widely used in enterprise-level applications.
- ODBC (https://docs.microsoft.com/en-us/sql/odbc/reference/odbc-overview) - A widely accepted API that provides a standardized way to access data from various database management systems. ODBC offers a consistent interface to access 
data, making it easy to develop database applications.
- OData (https://www.odata.org/) - An open protocol that enables the creation and consumption of queryable and interoperable REST APIs. OData simplifies the development of REST APIs and offers a standardized way to access data.
- Standard Webhooks (⭐1k) (https://github.com/standard-webhooks/standard-webhooks) - Open source tools and guidelines for sending webhooks easily, securely, and reliably.
⬆ back to top (#contents)
Structure and Validation
- JSON Schema (⭐3.1k) (https://github.com/json-schema-org/json-schema-spec) - A powerful tool for validating the structure of JSON data. JSON Schema enables developers to ensure that JSON data conforms to a specific structure, making 
it easier to process and manipulate.
- Schematron (https://www.schematron.com) - A rule-based validation language that enables developers to define and validate business rules, data reporting, quality control, and other validation scenarios. Schematron offers a flexible 
way to validate XML documents.
- XML Schema (https://www.w3.org/TR/xmlschema11-1/) - A schema language that offers facilities for describing the structure and constraining the contents of XML documents. XML Schema enables developers to ensure that XML data conforms 
to a specific structure, making it easier to process and manipulate.
⬆ back to top (#contents)
Contributing
Your contributions are always welcome! Please take a look at the contribution guidelines (https://github.com/stn1slv/awesome-integration/blob/main/CONTRIBUTING.md) first.
Reference in New Issue View Git Blame Copy Permalink