Azure Logic App: is it worth moving from a linear pattern to a star pattern?

Published by Camille SCHNEIDER
Category : Azure / Logic Apps / Microservices

If you are used to using Logic Apps, you are sure to be familiar with the functionality used to resubmit a given run. This feature can prove extremely useful, whether during development, or in a live environment. It essentially offers the possibility of re-running an instance from the start. In short, it is used to restart a process from the beginning, without requiring the presence of the factors that enabled the process to be run the first time (the trigger). This functionality is so valuable that it affects the design and implementation of our Logic App processes. However, Microsoft has announced a new Azure Logic App feature: being able to re-run a process from a specific action:

This made me think about the strategy to adopt when processes are to be designed with Logic Apps.

During the process design phase, it is important to consider the dependencies that can exist between Logic Apps, and how they are nested.


Linear pattern

Previously, to gain the full advantage of the “resubmit” functionality, it was useful to put any process involving a number of Logic Apps in place linearly:

Pattern lineaire

A linear pattern consists of separating out the various steps in a process, sharing each step’s responsibilities. For example, it can be useful to separate implementation of technical protocols (used to retrieve data from or send data to different systems) from purely business or functional processes. The benefit of the pattern above is that resubmitting a process is possible at any one of the steps in the sequence. The main drawback is reusability, as nested Logic Apps are strongly bound together. For example, in the diagram above, the second Logic App cannot be used without involving the third.


Star pattern

Once the functionality allows a resubmit to be run from a specific action, then I think a star pattern will have to be considered:

Pattern etoile

The star pattern works with one Logic App playing the role of a coordinator, calling the nested Logic Apps one after the other in the desired order. Once it is possible to resubmit from any action, then the star pattern offers the same possibilities as the linear pattern as regards resubmission. However, it also adds improved reusability. In fact, unlike the linear pattern, a star pattern means Logic Apps can be run independently from each other.



In conclusion, in comparison with a linear pattern, a star pattern delivers real independence between Logic Apps, and consequently an architecture more suited to microservices. For my part, until it is possible to resubmit a specific action within a Logic App, I will prefer to use the linear pattern. But the pattern question will be back on the table once this new functionality is released.