The S90.08B exam, part of the SOA Certified Professional Gen 2 credential path, validates your ability to design and architect service-oriented solutions using modern microservices patterns. This exam is intended for architects and senior developers who need to demonstrate practical competency in SOA design principles, services modeling, and microservices implementation. Arcitura Education's S90.08B (SOA Design & Architecture Lab with Services & Microservices) focuses on hands-on, scenario-driven assessment rather than pure memorization. This page outlines the exam structure, core topics, and a straightforward preparation strategy to help you succeed.
Use this topic map to guide your study for Arcitura Education S90.08B (SOA Design & Architecture Lab with Services & Microservices) within the SOA Certified Professional Gen 2 path.
The S90.08B exam combines multiple-choice items with scenario-based questions to assess both conceptual understanding and practical judgment. Questions progress in difficulty and require you to apply knowledge to realistic project situations.
Questions are designed to reflect real-world complexity; expect to weigh competing priorities such as performance, cost, and team skill availability.
A structured, topic-driven study plan helps you cover all domains efficiently and build confidence. Allocate 4-6 weeks and map your learning to the five core topic areas, starting with fundamentals and progressing to advanced scenarios. Regular practice with explanations reinforces weak areas and builds pattern recognition.
Explore other Arcitura Education certifications: view all Arcitura Education exams.
Strengthen your preparation with up-to-date resources from validexamdumps.com. These materials align to S90.08B and cover practical scenarios with clear explanations.
Visit the exam page to download the PDF, Online Practice Test, or get a Bundle Discount offer for both formats: SOA Design & Architecture Lab with Services & Microservices.
Design & Architecture with SOA, Services & Microservices and the Advanced SOA Design & Architecture with Services & Microservices domains typically account for 40-50% of exam items. The lab section tests your ability to apply these concepts in realistic scenarios. Invest extra study time in pattern selection, trade-off analysis, and architectural documentation.
You start with Fundamental SOA, Services & Microservices to establish principles and boundaries. Microservice Technology Concepts inform your tool and platform choices. Design & Architecture with SOA, Services & Microservices guides service decomposition and interface design. Advanced SOA Design & Architecture addresses integration, resilience, and operational concerns. Finally, the SOA Design & Architecture Lab with Services & Microservices brings all knowledge together in hands-on implementation and documentation tasks.
Hands-on experience is valuable but not required to pass. Prioritize labs that involve service contract design, message flow modeling, and architectural decision documentation. If you have access to containerization or orchestration platforms, practice deploying a multi-service application to reinforce deployment patterns. The exam tests your reasoning more than tool expertise, so focus on understanding the "why" behind each design choice.
Candidates often confuse SOA patterns with microservices patterns, overlook non-functional requirements (scalability, resilience) when choosing architectures, and fail to consider operational complexity and team skill. Another frequent error is selecting a technology without justifying it against business constraints. Always ask yourself: "Why is this the best choice given the requirements?" and document your reasoning.
In the final week, take a full-length timed practice test to identify remaining weak spots. Review explanations for every incorrect answer, not just the right one. Spend 2-3 days drilling scenario-based questions in your weakest domains. On the day before the exam, do a light review of key patterns and definitions; avoid heavy studying that might cause fatigue or confusion.
Refer to Exhibit.
Our service inventory contains the following three services that provide Invoice-related data access capabilities: Invoice, InvProc and Proclnv. These services were created at different times by different project teams and were not required to comply with any design standards. Therefore, each of these services has a different data model for representing invoice data.
Currently, each of these three services has a different service consumer: Service Consumer A accesses the Invoice service (1), Service Consumer B (2) accesses the InvProc service, and Service Consumer C (3) accesses the Proclnv service. Each service consumer invokes a data access capability of an invoice-related service, requiring that service to interact with the shared accounting database that is used by all invoice-related services (4, 5, 6).
Additionally, Service Consumer D was designed to access invoice data from the shared accounting database directly (7). (Within the context of this architecture, Service Consumer D is labeled as a service consumer because it is accessing a resource that is related to the illustrated service architectures.)
Assuming that the Invoice service, InvProc service and Proclnv service are part of the same service inventory, what steps would be required to fully apply the Official Endpoint pattern?
he Legacy Wrapper pattern can be applied so that Component B is separated into a separate utility service that wraps the shared database. The Legacy Wrapper pattern can be applied again so that Component C is separated into a separate utility service that acts as a wrapper for the legacy system API. The Legacy Wrapper pattern can be applied once more to Component D so that it is separated into another utility service that provides standardized access to the file folder. The Service Facade pattern can be applied so that three facade components are added: one between Component A and each of the new wrapper utility services. This way, the facade components can compensate for any change in behavior that may occur as a result of the separation. The Service Composability principle can be further applied to Service A and the three new wrapper utility services so that all four services are optimized for participation in the new service composition. This will help make up for any performance loss that may result from splitting the three components into separate services.
By applying the Legacy Wrapper pattern to separate Components B, C, and D into three different utility services, the shared resources within the IT enterprise (Database A, the legacy system, and the file folders) can be properly encapsulated and managed by dedicated services. The Service Facade pattern can then be used to create a facade component between Component A and each of the new wrapper utility services, allowing them to interact seamlessly without affecting Service Consumer A's behavior.
Finally, the Service Composability principle can be applied to ensure that Service A and the three new wrapper utility services are optimized for participation in the new service composition. This will help to mitigate any performance loss that may result from splitting the three components into separate services.
Refer to Exhibit.
Service Consumer A sends a message to Service A (1), which then forwards the message to Service B (2). Service B forwards the message to Service C (3), which finally forwards the message to Service D (4). However, Services A, B and C each contain logic that reads the contents of the message to determine what intermediate processing to perform and which service to forward the message to. As a result, what is shown in the diagram is only one of several possible runtime scenarios.
Currently, this service composition architecture is performing adequately, despite the number of services that can be involved in the transmission of one message. However, you are told that new logic is being added to Service A that will require it to compose one other service to retrieve new data at runtime that Service A will need access to in order to determine where to forward the message to. The involvement of the additional service will make the service composition too large and slow.
What steps can be taken to improve the service composition architecture while still accommodating the new requirements and avoiding an increase in the amount of service composition members?
This solution addresses the issue of the service composition becoming too large and slow by introducing a new Routing service that is invoked by messages read from a messaging queue. This allows Service A and Service C to determine where to forward messages to at runtime without the need for additional services in the composition. The Service Loose Coupling principle is applied to ensure that the new Routing service remains decoupled from other services so that it can perform its routing functions independently from service contract invocation.
Refer to Exhibit.
Service A is a task service that is required to carry out a series of updates to a set of databases in order to complete a task. To perform the database updates. Service A must interact with three other services that each provides standardized data access capabilities.
Service A sends its first update request message to Service B (1), which then responds with a message containing either a success or failure code (2). Service A then sends its second update request message to Service C (3), which also responds with a message containing either a success or failure code (4). Finally, Service A sends a request message to Service D (5), which responds with its own message containing either a success or failure code (6).
Services B, C and D are agnostic services that are reused and shared by multiple service consumers. This has caused unacceptable performance degradation for the service consumers of Service A as it is taking too long to complete its overall task. You've been asked to enhance the service composition architecture so that Service A provides consistent and predictable runtime performance. You are furthermore notified that a new type of data will be introduced to all three databases. It is important that this data is exchanged in a standardized manner so that the data model used for the data in inter-service messages is the same.
What steps can be taken to fulfill these requirements?
This approach isolates the services used by Service A, allowing it to avoid the performance degradation caused by multiple service consumers. By creating redundant implementations of Services B, C, and D that are accessed only by Service A, the Composition Autonomy pattern also ensures that Service A's runtime performance is consistent and predictable. Applying the Canonical Schema pattern ensures that the new type of data is exchanged in a standardized manner, ensuring consistent representation of the data model used for the data in inter-service messages.
Refer to Exhibit.
Service A sends a message to Service B (1). After Service B writes the message contents to Database A (2), it issues a response message back to Service A (3). Service A then sends a message to Service C (4). Upon receiving this message, Service C sends a message to Service D (5), which then writes the message contents to Database B (6) and issues a response message back to Service C (7).
Service A and Service D are located in Service Inventory
This solution addresses the two main challenges in the service composition architecture: the different XML schema used by services in Service Inventory A and Service Inventory B, and the incompatible data formats of the two databases.
By applying the Data Model Transformation pattern, data model transformation logic can be inserted to map the invoice-related data between the different XML schemas used by the services in Service Inventory A and Service Inventory B. This can be done at the appropriate points in the message flow: between Service A and Service B, between Service A and Service C, between Service C and Service D, and between the Service D logic and Database B.
By applying the Data Format Transformation pattern, data format transformation logic can be inserted to convert the XML-formatted data used by the services to the CSV format required by Database A, and to convert the proprietary XML schema used by Database B to the XML schema used by the services. This can be done between the Service B logic and Database A.
The Protocol Bridging pattern is not necessary in this case because all services are already communicating using the same protocol (presumably HTTP or a similar protocol).
Refer to Exhibit.
Service Consumer A sends a message to Service
By separating the individual implementations of Service A onto different physical servers, they can be isolated from each other and from other clients and applications in the IT enterprise, which can help improve performance. Additionally, using the Service Data Replication pattern to give each implementation of Service A its own copy of the data it requires from the shared database can help reduce the load on the shared database and improve performance. This can be especially important when a new service capability is added that requires access to the shared database, as it can help ensure that the performance of Service A is not impacted by the additional demands placed on the shared database.
