Our Design requirement is:-

From Framework Layer Level we will have to Create Work object down to the Implementation layer. i.e. the Someone who is logged in the FW layer will process some piece of information on an work object and then that information will have to be passed into various down the line Implementation layers and Work objects has to be spawned into the Implementation Layer as well.

We have come up with the below solutions:-

1. Agent Driven Approach :- The data will be extracted by the processor in the FW layer and will be kept in a Staging Table with Implementation specific information where the Work Object has to be spawned. Now Agents will be running in the individual Implementation layers. which will poll the staging table and once find a relevant entry will spawn the work item in the implementation Layer.
   1. Now we all know Agents are not one of the most reliable source and because of multi noded environment there will be always issues with locking unless properly handled. We cannot use queue for agent here since we are sitting at the FW layer and cannot queue to an Implementation level Agent. So these will have be Advance Agent.
2. Service Driven Approach:- In this scenario we will have to create a Service SOAP in the FW layer which then will be consumed by the IMPL layers for creation of the work items. This again will have to use Agents because the service will have to be polled frequently to see if there are any new entries in the Staging table or not.
   1. This again is not a very ideal scenario because every oncoming implementation will have the overhead of consuming the service. But one benefit is definitely because this is a service hence it can be consumed anywhere.
3. Direct Work Object Creation:- In this approach the work items will be created directly from FW to Implementation. where same set of starting flows will be used and the appropriate class will be passed as a parameter to the work object creation activity. It is working as we have done a small POC.
   1. This approach is highly against the proper coding practice as we should never entertain the work object creation from FW to Implementation or in other words the initiation of the WO shouldn't be top to bottom directly. Also doing this means we are restricting the flexibility as we are dictating that only work object can be created with that data rather the decision should be left to Implementation what exactly they want to do with the Data.
4. Listener Driven Approach:- In this approach the data will be extracted as an XML file and the XMl file will be placed in different folders for the appropriate Implementation layer and Implementation will then listen to these Files and process the data / create the WO.
   1. Overhead will be to maintain the Folders, Track the exceptions and creation of the listener activities in every implementation layer.

Which approach do you think make most of sense? any other solutions that you think is possible or you might have come similar requirement? All suggestions are welcome.

We are betting mostly on the Agent Driven approach