How can I run dependent asynchronous steps in the right order?

Write the dependency in the code: await the first operation, save its result, and use that result in the next operation. Repeat for each dependency. In this illustrative example, assume the named functions return promises:

async function buildReceipt() {
  const order = await loadOrder();
  const customer = await loadCustomer(order.customerId);
  const receipt = await createReceipt(order, customer);
  return receipt;
}

The second step needs order.customerId, so it comes after loadOrder() finishes. The third needs both order and customer, so it comes after both values have been obtained. Promises can be composed this way: await an operation, then pass its result to the next dependent operation. [S1] The function names and returned data here are placeholders, not assumptions about a particular service.

That only fits operations that can begin without results from one another. In this example, loadCustomer cannot be called with the order’s customer ID until the order has been loaded, and createReceipt needs the order and customer. Starting those steps before their inputs exist would not express the dependency.

Check each operation’s inputs: if a required value is produced by an earlier step, wait for that step and pass the value along. If there is no such dependency, those operations may be started together. The dependency order comes from the data each step needs, not merely from the order you happen to list the functions.

Start both operations together with Promise.all(), then use the results after it resolves. For example, assuming these placeholder functions return promises and neither needs the other’s result:

async function makeDashboard() {
  const [sales, inventory] = await Promise.all([
    loadSales(),
    loadInventory()
  ]);

  return buildDashboard(sales, inventory);
}

Here, loadSales() and loadInventory() are independent inputs to the final step. Promise.all() lets the independent operations run together rather than imposing an unnecessary serial wait; after both results are available, the code continues to buildDashboard. [S1] This example illustrates ordering only; it does not establish how any particular function handles errors or what data it returns.

Write down each step’s required inputs and where they come from. Then place each step after the operation that produces its inputs. Keep independent steps together only when neither needs the other’s result. For the receipt example, the dependency chain is: load order → load customer using the order’s customer ID → create receipt from order and customer.

A reusable pattern is:

async function runWorkflow() {
  const firstResult = await firstStep();
  const secondResult = await secondStep(firstResult);
  const thirdResult = await thirdStep(secondResult);
  return thirdResult;
}

Treat the names as placeholders and adjust the inputs to match your actual workflow. This pattern shows sequencing; it does not by itself define error handling, retries, or the behavior of the operations you call.