Make.com If/Else and Merge Tutorial: Build a Zero-Credit Data Normalizer

Introduction

If you pull customer records from two systems into one spreadsheet, one CRM, or one Slack channel, the fields never line up. HubSpot calls it one thing, Stripe calls it another, and a CSV export calls it a third. The usual Make.com fix is a Router with a copied set of downstream modules in every branch, which is painful to maintain and easy to break when one branch is edited and the others are not. Make’s If/Else and Merge modules, launched in March 2026, solve this exact problem. This tutorial builds a Data Normalizer with them: two sources enter, one clean record shape leaves, and the branching itself costs zero credits.

Quick answer

Add a Flow Control If/Else module, put one source mapping on each route, then add a Flow Control Merge module that maps both routes into the same output fields, so downstream modules see one stable record shape.

Evidence

The cost argument for this pattern comes straight from Make. Its If/Else and Merge help page states, in plain terms: “The If-else module uses operations but does not consume any credits,” and says the same of the Merge module. That is the whole reason a normalizer built this way is cheap: the decision and the rejoin are free, and you only pay credits for the modules that actually do work, such as the trigger and the destination app.

The pricing context makes the saving concrete. As of November 2026, Make’s pricing page offers a Free plan with 1,000 credits per month and a limit of two active scenarios. A scenario that duplicates five downstream modules across two Router branches burns ten credits per run instead of five, so on a Free plan a normalizer that rejoins the flow can nearly double how many runs fit in the monthly allowance. The same help page draws the line that matters for design: a Router “runs all routes and can’t be reconnected,” while If/Else runs only the first true condition and then Merge reconnects the flow into a single route.

A second primary source confirms the boundary you must respect. Make’s Router help page describes the Router as the module for splitting a flow into independent routes, which is the right tool when every branch should run. If/Else is the opposite choice, one decision, one winner, one flow afterwards. Picking the wrong one is the most common mistake with this feature, and the docs make the distinction explicit so you do not have to guess.

Prerequisites

• A Make.com account on any plan, including Free, since both modules are available to all Make users at no credit cost.
• A scenario with a trigger that carries a source identifier, for example a webhook that receives JSON with a source field, or a form that records where each record came from.
• Two record shapes to unify. This tutorial uses HubSpot and Stripe as the example pair, but the same steps work for any two sources, including a CSV row and a CRM record.
• A destination module to test with, such as Google Sheets Add a Row, so you can see the normalized output land in one place.

Step-by-step guide

Step 1: Sketch the normalizer on paper before opening Make

Write down the output shape first, not the branch logic. For this tutorial the normalized record has four fields: customer_name, customer_email, plan_name, and source_system. Every downstream module will read only these four fields, never the raw HubSpot or Stripe field names. That single decision is what makes the scenario maintainable: when a third source arrives, you change the normalizer, not the ten modules after it.

Next, write the mapping for each source. HubSpot might supply a company name and a contact email, while Stripe supplies a customer name and a billing email. The field names differ, but the meaning is the same, so both map into customer_name and customer_email. If one source lacks a field, decide the fallback now, for example an empty string or the word unknown, rather than discovering the gap during a live run.

Step 2: Add the If/Else module and set one condition

In your scenario, search for Flow Control > If-else and add it after the trigger. The module creates two routes: a conditional route and an Else route. These routes cannot be unlinked from the If/Else module, and the last module on a route cannot be deleted, which is Make enforcing the structure that makes Merge possible later.

Set the condition on the first route to test the source field. For example, set the condition to source equal to hubspot. Only the first condition that evaluates as true runs, so order matters if conditions could overlap. Keep the condition simple and testable: one field, one comparison, one expected value. Everything that is not HubSpot falls through to the Else route, which in this tutorial handles Stripe.

Run the scenario once with a HubSpot test record and once with a Stripe test record, and confirm in the execution log that only the expected route runs each time. If both routes appear to run, the condition is wrong, not the module. Check for a casing difference, such as HubSpot versus hubspot, or a trailing space in the incoming value.

Step 3: Put the per-source mapping on each route

This step is where most people overbuild. You do not need a transformation module in each branch if the only job is renaming fields. The Merge module itself carries the mapping, as Step 4 shows. Add a branch module only when a source genuinely needs work before merging, for example converting a Stripe amount in cents to dollars, or splitting a HubSpot full name into first and last name. Each module you add inside a branch costs a credit when that branch runs, so keep branch modules to real transformations and push pure renaming into the Merge mapping.

A useful rule is to count the credits before you build. If each branch needs two transformation modules, a run costs the trigger plus two branch modules plus the destination, and the If/Else and Merge modules add zero. Write that count next to your sketch, because it is the number you will compare against the Router version in Step 6.

Step 4: Add the Merge module and define the unified outputs

At the end of any route, add Flow Control > Merge. The Merge module is not available to add until after an If/Else flow has been set up, so if it does not appear in search, the If/Else module is missing or was removed. Connect the Merge module to all routes in the If/Else flow, either by dragging its icon to each route or by choosing Merge routes from the plus sign at the end of a route.

Now define one output per normalized field. For each output, enter an Output name, such as customer_email, then map an Output value for each route: on the conditional route map the HubSpot email field, and on the Else route map the Stripe billing email field. Repeat for customer_name, plan_name, and source_system. The source_system output is worth mapping explicitly, with the fixed text hubspot on one route and stripe on the other, because downstream debugging is much easier when every normalized row says where it came from.

This mapping is the normalizer. After the Merge module, every downstream module reads customer_email and gets the right value no matter which source supplied the record. No downstream module needs to know that HubSpot and Stripe name their fields differently.

Step 5: Connect one shared downstream flow and test both paths

After the Merge module, add your destination module once, not once per branch. Map its fields to the Merge outputs: the name column reads customer_name, the email column reads customer_email, and so on. This is the payoff of the whole pattern. A change to the destination, a new column, a different sheet, or an added Slack notification, is made once and applies to both sources.

Test with both sources again, end to end. Send a HubSpot record and confirm one clean row appears with the HubSpot values. Send a Stripe record and confirm one clean row appears with the Stripe values, in the same columns. Then check the execution history for credit use: the If/Else and Merge steps should show as operations that consumed no credits, matching the help page statement.

Step 6: Compare against the Router version and keep the cheaper design

Build the mental comparison before deciding this pattern is always right. A Router version of the same scenario would duplicate the destination module in both branches, doubling its credit cost and doubling every future edit. For a five-module downstream flow running 200 times a month on the Free plan, that duplication alone is 1,000 extra credits, the entire monthly allowance. The If/Else plus Merge version runs the downstream flow once per record, regardless of source.

The tradeoff is real, though. A Router is still correct when both branches must run, such as logging a record and sending a notification for the same event. If/Else deliberately runs only one branch, so it cannot do two independent jobs at once. Use the decision rule from the Evidence section: one decision and one rejoin means If/Else and Merge, several independent jobs means Router.

Step 7: Extend to three sources with a nested If/Else

When a third source arrives, nest a second If/Else module inside the Else route. The outer module asks whether the record is HubSpot, and the inner module asks whether the remaining record is Stripe or, by elimination, the third source. Each nested If/Else closes with its own Merge module, so each decision level stays readable in the visual editor instead of collapsing into one wide tangle of branches.

Keep nesting shallow. Two levels handle three or four sources cleanly. Beyond that, the scenario becomes hard to read, and a lookup table pattern, where a small table maps source names to field names, is usually clearer than a third level of nesting. The normalizer you built in Steps 2 to 5 still works as the core: the nested version only adds one more decision before the same Merge outputs.

Troubleshooting

The Merge module does not appear in search

This happens when no If/Else flow exists yet in the scenario. The Merge module only works with an If/Else module and cannot be added on its own. Add Flow Control > If-else first, confirm its two routes are visible, and then search for Merge again. If you added a Router instead of If/Else, replace it: Router paths cannot be merged, and no setting changes that.

Only one source produces correct output, the other writes blanks

The usual cause is an unmapped Merge output on one route. Open the Merge module and check every output on both routes. A field mapped only on the conditional route comes out empty for every Else record, and vice versa. Fill the missing side with the correct source field or a fixed fallback value, then rerun the failing source and confirm the row fills in.

The wrong branch runs for a known record

The condition is evaluating differently than expected, most often because of casing, whitespace, or a field path that points at the wrong bundle item. Add a temporary test run and inspect the actual incoming value in the execution log before changing the condition. Normalize the comparison if needed, for example by comparing a lowercased version of the source field, or by fixing the sender to emit one consistent value.

Credits are higher than expected even though If/Else and Merge are free

Check the branch and destination modules, not the flow control modules. A transformation module inside a branch still costs a credit when its branch runs, and a destination module with a search step before its write step costs a credit for each step. The zero-credit claim covers only If/Else and Merge themselves. If a branch contains a module that runs on every record regardless of source, move it after the Merge module so it runs once in the shared flow.

FAQ

See the front matter FAQ entries for the most common questions: credit cost, Router compatibility, route count, empty outputs, single-source value, and when to choose a Router instead.

Conclusion

A Data Normalizer built from Make’s If/Else and Merge modules gives you one stable record shape for every source, one shared downstream flow to maintain, and zero credits spent on the branching itself. Start with two sources and four output fields, prove both paths with real test records, and only then add a nested level for a third source. For the next step, read the guide to preventing duplicate records when a Make scenario reruns, since a normalizer that runs twice should still write each record once, and the Make.com error handlers tutorial for what to do when a normalized run fails halfway through. Builders turning scenarios into reusable tools should also read the Make.com MCP server tutorial.

Frequently asked questions