Free TCA-Tibco-BusinessWorks Practice Test Questions and Answers (2026)

To achieve an active-passive failover model, where a process runs on a secondary AppNode only after the primary one fails, the process starter's activation must be set to Single AppNode. This setting ensures the process is active on only one AppNode within an AppSpace at any given time. The failover mechanism itself is managed by the underlying TIBCO BusinessWorks platform. When the AppSpace is configured for fault tolerance (with at least two AppNodes), the platform detects the failure of the active AppNode and automatically starts the process on a standby AppNode, thus achieving the desired failover behavior while respecting the single-instance constraint.

A. Multiple AppNodes: This setting activates the process starter on all AppNodes in the AppSpace simultaneously, which is used for load balancing or parallel processing, not active-passive failover.

C. Elastic AppNodes: This is not a standard activation setting within TIBCO BusinessWorks. It describes a general infrastructure capability rather than a specific process configuration option.

D. Failover AppNodes: This term describes the desired architectural outcome (high availability) but is not the name of the actual activation setting configured on the process starter in TIBCO BusinessWorks.

1. TIBCO BusinessWorks™ Application Development Guide (Version 6.8, March 2022):

Page 131, Chapter 10: Components, Section: "Component Process Starters": This section explicitly lists the available activation settings. It states, "The Activation check box in the Process Starters tab allows you to specify whether a process starter in a process is activated when it is deployed. You can select Single AppNode or Multiple AppNodes." It defines "Single AppNode" as: "The process starter is enabled on a single AppNode in an AppSpace." This confirms the name and function of the correct setting.

2. TIBCO BusinessWorks™ Administration Guide (Version 6.8, March 2022):

Page 71, Chapter 7: Fault Tolerance: This chapter explains the mechanism that enables the failover scenario. It states, "For fault tolerance, an AppSpace must have a minimum of two AppNodes... When an AppNode fails, the TIBCO Enterprise Administrator agent on the other machine detects the failure and starts the application on the available AppNode." This clarifies that the "Single AppNode" setting works in conjunction with a fault-tolerant AppSpace to achieve the goal.

According to TIBCO EMS documentation, the server on which a route is defined in the routes.conf file is the server that actively initiates the connection. In this scenario, only Server-A has a route entry for Server-B, so Server-A initiates the connection.

The term "active-active" for a route implies a symmetric configuration where both servers can initiate the connection, which requires route entries on both servers. The current setup is asymmetric. However, no parameter shown, including zonetype=lhop (which only affects message forwarding logic), prevents an administrator from adding a corresponding route entry to Server-B's configuration file. Therefore, the route can be reconfigured or "promoted" to an active-active state.

B. Server-B has an empty routes.conf file, so it cannot initiate a connection to Server-A; it only listens for incoming route connections.

C. There is no technical constraint in the provided configuration that prevents an administrator from making the route bi-directional ("active-active") by updating Server-B's configuration.

1. TIBCO Enterprise Message Service™ User's Guide (Version 10.2), Chapter 12: Routing Messages Between Servers, Section: "Configuring Routes", p. 328. This section states, "The server on which you define the route actively attempts to establish a connection with the other server." This directly supports answer A.

2. TIBCO Enterprise Message Service™ User's Guide (Version 10.2), Chapter 12: Routing Messages Between Servers, Section: "Configuring Routes", p. 328. The guide explains, "To create a two-way route, you must configure the route on both servers." This implies that a one-way configuration can be changed to a two-way ("active-active") one by adding the necessary configuration, supporting answer D.

3. TIBCO Enterprise Message Service™ User's Guide (Version 10.2), Chapter 12: Routing Messages Between Servers, Section: "Server Zones", p. 331. The description of lhop zone type confirms it only governs message forwarding behavior ("does not route messages to other zones") and does not impose restrictions on connection topology, which refutes the reasoning for option C.

The JMS Receive Message activity is the correct choice for handling asynchronous, correlated replies. After sending the initial message with JMS Send Message, the process can use JMS Receive Message as an inline activity to wait for the reply. To ensure the correct reply is processed, especially when messages are out of order, a message selector is configured on the JMS Receive Message activity. This selector filters incoming messages based on a JMSCorrelationID, which would have been set by the initial sender and copied into the reply message by the backend application.

B. Get JMS Queue Message: This activity polls for a message on demand rather than acting as an event-driven listener, making it less efficient for waiting on an asynchronous reply.

C. Wait for JMS Request: This is not a valid activity in the TIBCO BusinessWorks palette. The standard "Wait" activity is for process notifications, not direct JMS message correlation.

D. JMS Request Reply: This activity is designed for synchronous request-response interactions where the process blocks and waits for an immediate reply, which contradicts the asynchronous nature of the scenario.

1. TIBCO BusinessWorks™ Palette Reference, Version 6.8, "JMS Palette > JMS Receive Message" section.

Page 218: "The JMS Receive Message activity is an event source that starts a new process instance when a JMS message is received... This activity can also be used in the middle of a process to wait for an incoming JMS message."

Page 220, "Message Event" Tab: This section details the "Message Selector" field, stating, "A string that is a valid JMS message selector. This allows you to filter messages based on the message headers or properties." This directly supports its use for correlation.

2. TIBCO BusinessWorks™ Palette Reference, Version 6.8, "JMS Palette > JMS Request Reply" section.

Page 213: "The JMS Request-Reply activity sends a JMS message and waits for a response." This confirms its synchronous, blocking behavior, making it unsuitable for the described asynchronous scenario.

3. TIBCO BusinessWorks™ Concepts, Version 6.8, "Messaging" chapter, "Request-Reply" section.

Page 101: The documentation describes two request-reply operations. The asynchronous model is detailed: "The service requester sends a request message containing a unique correlation ID... The service requester then continues its processing. At a later time, the service requester receives the reply message and uses the correlation ID to match the reply to the appropriate request." The implementation for this pattern uses JMS Send Message followed by a JMS Receive Message with a message selector.

The bwagent is the core daemon process required on the remote machine to manage a TIBCO BusinessWorks domain. The Deployment Servers view within TIBCO BusinessStudio for BusinessWorks establishes a direct connection to the bwagent on the target server. This connection allows developers to discover runtime entities like AppSpaces and AppNodes, and to push application archives for deployment. Without the bwagent running, BusinessStudio has no endpoint to communicate with for remote administration and deployment tasks.

B. bwinstall: This is the installer utility used for the initial setup and installation of TIBCO BusinessWorks software, not for runtime deployment operations.

C. bwadmin: This is the command-line administration utility. While it is used for deployment, it is a separate client that also communicates with the bwagent. It is not required to be running for BusinessStudio to perform a deployment.

D. bwdesign: This is the executable that launches the TIBCO BusinessStudio for BusinessWorks design-time environment itself. It is the client performing the deployment, not the server-side utility being connected to.

1. TIBCO BusinessWorks™ Application Development, Release 6.8, September 2022: In the chapter "Deploying an Application", the section "Deploying an Application from TIBCO Business Studio™ for BusinessWorks™" explicitly states in Step 1: "In TIBCO Business Studio for BusinessWorks, connect to the bwagent." This confirms that the bwagent is the required target for the connection.

2. TIBCO BusinessWorks™ Administration, Release 6.8, September 2022: The chapter "bwagent" describes its function: "The bwagent is a daemon process that runs on every TIBCO BusinessWorks machine... The bwagent can be managed using the bwadmin utility or the Admin UI. The bwagent exposes REST APIs that can be used to manage the run time." BusinessStudio utilizes these REST APIs for remote management.

3. TIBCO BusinessWorks™ Concepts, Release 6.8, September 2022: The chapter "Administration Concepts" under the section "bwagent" details its role as the central point of administration: "The bwagent is the agent that is responsible for managing and monitoring the run time. It synchronizes data from the data store and pushes changes to the AppNodes." This highlights its essential role for any administrative action, including deployment from BusinessStudio.

TIBCO BusinessWorks shared modules are designed to promote reusability and modularity. They export specific components for use in application modules or other shared modules. Public processes are explicitly designated for external invocation, allowing other modules to reuse common business logic. Shared resources, such as JDBC or JMS connections, are also exported. This allows multiple applications to use a single, centrally managed resource configuration, ensuring consistency and simplifying maintenance. These two functionalities form the core of what a shared module exposes for reuse.

A. reference bindings: Reference bindings are configured at the application level to link a component reference to a concrete service, not exported by the shared module itself.

B. private processes: By definition, private processes are encapsulated within the shared module for internal logic and are not visible or accessible to other modules.

D. service bindings: Service bindings, which expose a service via a specific transport (like HTTP), are configured in the application, not exported from the shared module.

1. TIBCO BusinessWorks™ Concepts Guide (Version 6.8, Page 53, "Shared Modules"): "A shared module can contain processes, schemas, and resources. Processes in a shared module can be either public or private... Shared resources in a shared module can be used by application modules that have a dependency on the shared module." This directly supports that public processes and shared resources are the exported functionalities.

2. TIBCO BusinessWorks™ Application Development Guide (Version 6.8, Page 101, "Process Visibility"): "Processes in shared modules can be either public or private. Public processes can be called from other modules. Private processes can only be called by other processes in the same shared module." This confirms the role of public processes as an exported asset.

3. TIBCO BusinessWorks™ Application Development Guide (Version 6.8, Page 103, "Shared Resources in a Shared Module"): "You can add shared resources to a shared module. The shared resources can be used by the application module that has a dependency on the shared module." This verifies that shared resources are a key exportable functionality.

In TIBCO ActiveMatrix BusinessWorks, error handling at the activity level is primarily implemented using two mechanisms. The first is an Error Transition, which is a specific type of transition link originating from an activity that is executed only when that activity throws a fault. The second method is using a Fault Handler, which is attached to a Scope. By placing one or more activities inside a Scope, the Fault Handler acts as a structured try-catch block, catching any unhandled exceptions from the enclosed activities and executing a defined error-handling process.

B. onError Activity: There is no standard, built-in activity named "onError" in the TIBCO ActiveMatrix BusinessWorks palettes for general error handling.

C. Conditional Transitions: These transitions execute based on the evaluation of a data-based XPath expression (e.g., statuscode=200), not on the occurrence of a fault state.

E. Event Handlers: Event Handlers are designed to process asynchronous events (like timers or incoming messages) that can occur at any point, not to handle synchronous faults from activities.

1. TIBCO ActiveMatrix BusinessWorks™ Concepts, Release 6.8.1, March 2022:

For Error Transitions (A): Chapter 6: Process Definition, Section: "Transitions". The documentation states, "There are three types of transitions: Success, Success with conditions, and Error... An error transition is created to handle an error that occurs when the activity is running."

For Fault Handlers (D): Chapter 6: Process Definition, Section: "Scopes". The documentation explains, "A scope is a container for a collection of activities... A scope can have one or more fault handlers to catch and handle faults that may be thrown by the activities inside the scope."

For Conditional Transitions (C): Chapter 6: Process Definition, Section: "Transitions". This section distinguishes "Success with conditions" transitions, which are based on XPath, from Error transitions.

For Event Handlers (E): Chapter 6: Process Definition, Section: "Event Handlers". This section describes how event handlers are used for asynchronous events, separate from the main process flow.

The SOAP Request/Reply activity is the standard and most appropriate tool in TIBCO BusinessWorks for consuming external SOAP-based web services. This activity functions as a web service client by utilizing a Web Services Description Language (WSDL) file to configure the connection details, operations, and message structures. It automatically handles the creation of the SOAP request envelope and the parsing of the SOAP response envelope, simplifying the integration process for the developer. This makes it the specific and recommended choice for invoking traditional web services.

A. Invoke API activity: This activity is specifically designed for invoking REST APIs that are defined using an OpenAPI (formerly Swagger) specification, not for general SOAP web services.

B. Invoke activity: This is used to call another TIBCO BusinessWorks process (a sub-process) within the same application module, not for communicating with external services.

D. HTTP Request/Response activity: This is a generic HTTP client. While it could be used to manually construct and send a SOAP request, it lacks the built-in WSDL parsing and SOAP envelope management features.

1. TIBCO BusinessWorks™ Palette Reference, Version 6.8, "SOAP Palette" section, "SOAP Request Reply" subsection: "The SOAP Request Reply activity is used to invoke a specific operation of a web service. The activity is a client that sends a request to the web service and waits for a response." (This document explicitly states the purpose of the activity is to invoke a web service).

2. TIBCO BusinessWorks™ Palette Reference, Version 6.8, "REST & JSON Palette" section, "Invoke API" subsection: "The Invoke API activity is used to invoke a REST API. The activity uses a Swagger file that defines the REST API to configure the request and response." (This clarifies that Invoke API is for REST, not general web services).

3. TIBCO BusinessWorks™ Palette Reference, Version 6.8, "General Activities Palette" section, "Invoke" subsection: "The Invoke activity is used to invoke a subprocess." (This confirms the activity is for internal process calls).

In TIBCO BusinessWorks, a project is composed of modules, which are the fundamental units of design and organization. There are two distinct types of modules available for development. The Application Module is the primary module that contains the business logic and process starters, forming the core of a deployable application. The Shared Module is designed to contain reusable components, such as common processes, schemas, or shared resources (like JDBC or JMS connections), which can be imported and used by multiple Application Modules, promoting modularity and reusability.

B. BusinessWorks Module: This is a general term describing any module created in the environment, not a specific, selectable type like "Application" or "Shared".

D. Package module: Packages are organizational folders used within a module to group related assets like processes and schemas; it is not a type of module itself.

1. TIBCO BusinessWorks™ Concepts Guide (Version 6.8), Chapter: "Projects", Section: "Modules".

The documentation states: "There are two types of modules: application modules and shared modules. An application module is the main module of an application. A shared module contains reusable assets." This directly confirms the two correct types.

2. TIBCO BusinessWorks™ Application Development Guide (Version 6.8), Chapter: "Creating a Project", Section: "Creating a Module".

This section details the wizard for creating a new module, where the developer is explicitly prompted to select the module type, with the available choices being "Application Module" and "Shared Module". This reinforces the distinction and existence of only these two types.

The standard and most efficient method in TIBCO ActiveMatrix BusinessWorks for implementing a WSDL with a single Port Type containing multiple operations is to create a single process. This process acts as the implementation for the entire service defined by the Port Type. A starter activity, such as a SOAP Service binding, is configured to listen for incoming requests for all defined operations. The process logic then typically uses a control flow activity like "Pick" with multiple "OnMessage" events (one for each operation) to branch the execution path based on the specific operation that was invoked.

A. Create two processes, and remove one operation in both processes

This is an inefficient and non-standard approach. It unnecessarily complicates the design and maintenance by splitting a single logical service (Port Type) into multiple process definitions.

B. Create two applications that implement both operations, and set the activation mode to single.

Application configuration and activation modes are deployment-time concerns, not design-time solutions for implementing the logic of multiple operations within a single service.

C. Create a single process, and use a constructor for both operations.

"Constructor" is not a valid or recognized term for a process starter or event source activity in the context of TIBCO ActiveMatrix BusinessWorks web service implementation.

1. TIBCO ActiveMatrix BusinessWorks™ Concepts, Release 6.8, Chapter 7: Developing a SOAP Service, Section: Creating a Process to Implement the Service Operations.

This chapter describes the standard workflow for creating a SOAP service. It states, "When you create a SOAP service, a process is created with a Service activity. The process implements the operations of the service." This confirms that a single process is used to implement the service's operations. The wizard-generated process for a multi-operation WSDL includes a Pick activity with an OnMessage event for each operation, demonstrating the single-process approach.

2. TIBCO ActiveMatrix BusinessWorks™ Bindings and Palettes Reference, Release 6.8, Chapter 16: SOAP Palette, Section: Service.

The documentation for the Service resource explains that it is used to "implement a web service based on a WSDL file." It details how the binding is configured for the operations defined in the WSDL's Port Type, reinforcing that a single service configuration within a single process handles all operations of a given Port Type. The "Receive" action is conceptually handled by the OnMessage event within the process.

To make a Custom XPath function available to other projects at design time, a two-step process is required. First, the plug-in project containing the function must be packaged by exporting it as "deployable plug-ins and fragments." This creates a shareable OSGi bundle (a JAR file). Second, this exported bundle must be installed into the TIBCO Business Studio "host repository." This action registers the plug-in with the design-time environment, making the custom function accessible to all projects within that instance of TIBCO Business Studio.

B. Installing directly into a target project is not the standard mechanism; this action does not make the function available to other projects.

C. Exporting the resource is only the first step. Without installing it into the host repository, other projects cannot discover or use it.

D. Adding the function to a single target project is a one-time use case and does not fulfill the requirement of making it available to other projects.

1. TIBCO BusinessWorks™ Container Edition Documentation, Application Development Guide, "Developing an XPath Custom Function", section: "Making the Custom XPath Function Available at Design Time".

Quote/Content: The documentation explicitly states, "To make the custom XPath function available at design time, you must export the custom XPath function plug-in project as a deployable plug-in and fragment and install it in the TIBCO Business Studio for BusinessWorks host repository." It then details the two steps: 1) "From the menu, click File > Export... select Deployable plug-ins and fragments" (corresponds to option E), and 2) "...on the Destination tab, select Install into host. Repository" (corresponds to option A).

Managed fault tolerance in TIBCO ActiveMatrix BusinessWorks establishes an active-standby configuration. It requires the group persistence mode, which uses a database for both process state persistence and for coordinating among AppNodes to elect a single active leader. This coordination inherently makes the AppNodes "aware" of each other's presence and status.

Non-managed fault tolerance creates an active-active configuration where all AppNodes run concurrently and independently. An external load balancer is required for failover. This model requires the datastore persistence mode for a shared state, but the AppNodes themselves do not coordinate and are "unaware" of other instances in the AppSpace.

A. The persistence modes are incorrect. Memory persistence is not for fault tolerance, and group persistence is for managed, not non-managed, fault tolerance.

C. Both fault tolerance models support checkpointing. It is the fundamental mechanism for saving process state to enable recovery after a failure in either model.

D. This describes the outcome (single vs. multiple active engines) but not the core configuration requirement or architectural principle as accurately as options B and E.

1. TIBCO BusinessWorks™ Container Edition Application Development, Release 2.8, "Fault Tolerance" chapter.

Section: Managed Fault Tolerance: "The persistence mode must be set to group." and "The AppNodes are aware of each other and one of the AppNodes is elected as the primary (active) node." This directly supports options B and E.

Section: Non-managed Fault Tolerance: "The persistence mode must be set to datastore." and "The AppNodes are unaware of each other." This also directly supports options B and E.

2. TIBCO BusinessWorks™ Container Edition Application Monitoring and Troubleshooting, Release 2.8, "Engine Persistence Modes" section.

Subsection: Group: "The group engine persistence mode is used for managed fault tolerance." This confirms the requirement for option B.

Subsection: Datastore: "The datastore engine persistence mode is used for non-managed fault tolerance." This also confirms the requirement for option B.

To make a third-party JDBC driver, such as one for Oracle, available to the TIBCO BusinessWorks runtime environment, a two-step process is required. First, the bwinstall utility must be run. This command packages the driver JAR file(s) into a format that the BusinessWorks environment recognizes and places it in the correct directory within the TIBCO installation. Second, the bwadmin utility is used to upload this packaged driver to the bwagent and then install it into the specific domain, AppSpace, and AppNode where it will be used by applications.

A. Manually copying the JAR to the bwagent lib folder is incorrect. This bypasses the necessary registration and packaging process managed by the bwinstall utility.

B. The runtime classpath is managed by the BusinessWorks environment. Placing the driver in an arbitrary folder on the classpath will not make it available to the runtime correctly.

D. While bwinstall does copy the file to a specific third-party driver location, the required action is to use the utility, not to perform a manual file copy.

1. TIBCO ActiveMatrix BusinessWorks™ Installation Guide, Version 6.8, Chapter 5: Post-Installation Tasks, Section: "Installing Third-Party Drivers". This section explicitly states: "After installing TIBCO ActiveMatrix BusinessWorks, you must run the bwinstall utility to install the third-party drivers that are required by the plug-ins used in your environment." It provides the command syntax: TIBCOHOME/bw/6.x/bin/bwinstall -driver.

2. TIBCO ActiveMatrix BusinessWorks™ Administration Guide, Version 6.8, Chapter 10: Working with Drivers, Section: "Installing a Driver". This section details the process using bwadmin: "After a driver is available in the file system, it must be installed in an AppNode... Use the install driver command to install a driver in an AppNode." It also describes the prerequisite step of uploading the driver to the agent using the bwadmin upload command.

The key distinction is between an administrative action and a system fault. Managed Fault Tolerance is designed to provide high availability by automatically responding to an unplanned failure of an AppNode. When an administrator explicitly issues a "stop" command, it is a deliberate, planned action. The TIBCO Enterprise Administrator (TEA) interprets this as an intentional directive to halt the application across the entire AppSpace. Consequently, the active instance on AppNode A1 is stopped, and the standby configuration on AppNode A2 is also removed, changing its state to "Stopped". The system will not initiate a failover, as no fault has occurred.

A. This describes the behavior of an automatic failover, which is triggered by an AppNode failure (e.g., a crash), not a deliberate administrative "stop" command.

C. The "stop" command applies to the application within the entire AppSpace; it would not leave an instance in a "Standby" state, as this would contradict the stop directive.

D. A manual stop does not trigger activation on another node. Furthermore, the statement that it would be activated but not process requests is logically inconsistent.

---

1. TIBCO BusinessWorks™ Container Edition Application Monitoring and Troubleshooting, Version 2.8.1, Chapter 2: Administering Applications, AppSpaces, and AppNodes, Section: Stopping an Application.

This document explicitly states: "When you stop an application, the application is stopped on all the AppNodes in an AppSpace." This directly supports the chosen answer, confirming that the stop command is a global action for the application within its AppSpace.

2. TIBCO BusinessWorks™ Container Edition Concepts, Version 2.8.1, Chapter 5: Administration Concepts, Section: Fault Tolerance.

This section clarifies the trigger for failover in managed fault tolerance mode: "...if an AppNode running an application fails, the TIBCO Enterprise Administrator agent automatically starts the application on another AppNode in the same AppSpace." This confirms that the trigger is a failure, not a manual stop command, thereby invalidating options A and D.

3. TIBCO BusinessWorks™ Container Edition Concepts, Version 2.8.1, Chapter 5: Administration Concepts, Section: Application State.

This section describes the various states of an application, including "Running," "Stopped," and "Standby." An administrative stop command transitions the application to the "Stopped" state on all nodes, not leaving one in "Standby" (invalidating option C).

In TIBCO Business Studio™ for BusinessWorks™, breakpoints are dynamic and can be managed during an active debug session. A developer can add, remove, or disable breakpoints while the application engine is running in debug mode. The engine does not need to be restarted for these changes to take effect. This functionality allows for an efficient and interactive debugging process, enabling developers to pause execution at newly identified points of interest without interrupting the entire session.

B. True: This is incorrect. Requiring an engine restart to apply a breakpoint would be highly inefficient and contradicts the standard debugging capabilities provided by TIBCO Business Studio.

1. TIBCO BusinessWorks™ Application Development Guide (Version 6.8, March 2022): In the chapter "Testing and Debugging an Application," the section "Setting Breakpoints" states, "You can set breakpoints on activities before you start the debugger or during the debug session." The ability to set breakpoints "during the debug session" explicitly confirms that a restart is not required. (Refer to the "Debugging the Application" > "Setting Breakpoints" section).

2. TIBCO BusinessWorks™ Application Development Guide (Version 6.6, May 2020): The chapter on "Testing and Debugging an Application" similarly describes the process. In the "Debugging Perspective" section, it details how to interact with a running debug session, including adding breakpoints on the fly without mentioning any requirement for an engine restart. This dynamic capability is a core feature of the debugger.

To implement basic authentication for a TIBCO BusinessWorks 6 REST service, a developer must perform three key configuration steps. First, on the HTTP Connector shared resource, the "Authentication" option must be enabled. Second, this requires the selection and configuration of an "Identity Provider" shared resource, which is responsible for validating the user's credentials (e.g., against an XML file, LDAP, or database). Finally, authentication must be enabled on the specific service component's binding configuration to enforce the security policy on incoming requests.

A. Specifying an SSL Server Configuration is for enabling confidentiality (HTTPS), not authentication. While recommended, it is not a mandatory step for configuring the basic authentication mechanism itself.

B. "Confidentiality" is the setting for enabling SSL/TLS to encrypt traffic. It is distinct from "Authentication," which is the process of verifying a user's identity.

C. An LDAP shared resource is a specific type of Identity Provider. The configuration requires a generic "Identity Provider" resource, which could be based on other sources like an XML file.

1. TIBCO BusinessWorks™ Bindings and Palettes Reference, Release 6.8, "HTTP Connector" section, "Security" tab.

Page 221 (PDF version): This section details the configuration of the HTTP Connector shared resource. It states, "Select the Authentication check box to enable basic authentication. To use Basic Authentication, you must configure an Identity Provider shared resource." This directly supports the first two parts of the correct answer.

2. TIBCO BusinessWorks™ Bindings and Palettes Reference, Release 6.8, "Identity Provider" section.

Page 227 (PDF version): This section describes the Identity Provider shared resource, explaining its role: "The Identity Provider shared resource is used to authenticate an incoming request." It lists the different types, including XML and LDAP, confirming that "Identity Provider" is the correct general term.

3. TIBCO BusinessWorks™ Container Edition Application Development, Release 2.7, "Securing a Basic REST Service" tutorial.

Page 211 (PDF version): In the steps for securing a REST service, the guide instructs the user to: "In the HTTP Connector editor, click the Security tab and select the Authentication check box. Click the Browse button next to the Identity Provider field to select an identity provider." This confirms the required linkage between enabling authentication and specifying an Identity Provider. It also shows that enabling authentication on the component is a necessary final step.