Whether an approach is “easiest” or “best” will depend upon a number of factors. Any responses you get in this forum should be viewed as “might work for your scenario”. 
Here are my thoughts for your consideration.
-
API client and server only. Assuming there is an application of some sort that accepts order requests. API clients want to know the order status. The client calls the application via its API to get the status. No intermediiary.
-
Perhaps the application is unable to expose an API in the desired manner. Can introduce an intermediary to help. wM Integration Server is pretty good at this. Can provide payload transformation, protocol translation, etc. For example, application (back end) might only be capable of supporting SQL statements or having stored procs called to do something. The intermediary would expose, perhaps, a JSON over HTTP interface on behalf of the application. It would pass the data from the JSON payload as needed to the SQL statement or stored proc inputs, make the DB call, then return the response data in the response JSON. Or could use XML instead of JSON. Or whatever. The intermediary is between the client and the server (back end) providing a path for them to interact.
-
Perhaps there is no obvious/existing application that provides the desired function that would be accessed via API. Where to put that functional implementation? Many put what I would consider “application function” into the middleware tool. Certainly, the middleware tool vendors encourage this as well. And can be effective. In this case, the intermediary is also the back end.
-
Now that there is an API available, might want to manage that in some way. Access control. Track usage. Other fun stuff. Can introduce an API gateway (another intermediary) for these functions. Integration Server can perform some of these things but API Gateway is ready-made for such activity. Generally, the API hosts the interface definition not the implementation. The gateway passes the data on to something else that does the actual work.
The fun part of this is sometimes it is not clear which tool should/could be used for 2, 3 and 4. The functional part of “get order status” would normally be in the order application, accessed via API. But in the absence of an order application, should the intermediary host that? If so, which one, the “transformer/translater” or the “gateway”?
What to do depends entirely on your environment in terms of applications, infrastructure and available skill sets.
Client → Application (API)
Client → Integration Server (API interface) → Application (API implementation)
Client → API GW (API interface translation) → Application (API implementation)
Client → API GW (API interface) → Application (API implementation)
Client → API GW (API interface) → Integration Server (API interface translation) → Application (API implementation)
Client → API GW (API interface) → Integration Server (API implementation)
Client → API GW (API implementation)
For your specific scenario regarding filling in email text templates, I would avoid doing that in the intermediary. An application where users can more readily update the template(s) as needed is what I would suggest. IMO, make every effort to use API GW as a pass-through only. Use it for access control and tracking and put transformation/translation elsewhere when possible.
Of course, just my POV. Others undoubtedly will have additional suggestions.
#API-Gateway#webMethods