How to Build Your First n8n Integration (Step-by-Step)

Every n8n integration you will ever build has the same bones: something happens somewhere, n8n hears about it, reshapes the data, and hands it to the next system. Once you've built one properly, the second takes a fraction of the time. The steps below walk through a concrete first build: catch a form submission, clean it up, log it to a Google Sheet, and ping a Slack channel. By the end you'll have a working integration and a mental model you can reuse for almost anything.

I'm Maaz Siddiqui. I build n8n integrations for clients in production, so this guide is the version I wish I'd had when I started, not a tour of every button in the editor. It's beginner-to-intermediate, accurate to mid-2026, and focused on the parts that matter once you're past your first hour.

What an n8n integration is

People use "integration" two ways in the n8n world, and it's worth keeping them straight.

The narrow meaning is a single app connection: the Slack node, the Google Sheets node, the HTTP Request node hitting some API. The broader meaning, the one you'll use day to day, is a workflow that ties several of these together to do a real job. When a client says "build me an n8n integration between Typeform and our CRM," they mean the second thing: a workflow that listens, transforms, and delivers.

Either way, the unit you assemble is the node. Each node does one thing. You wire them left to right, data flows down the connections as items (n8n passes data around as an array of JSON items), and each node operates on what the node before it handed over.

Prerequisites

Before you build anything, get these in order:

• An n8n instance. You have two paths. n8n Cloud is hosted for you, fastest to start, no server to manage. Self-hosted (Docker is the common route) gives you full control and is cheaper at scale, but you own the upkeep. One difference that bites beginners: reading and writing files to disk isn't available on n8n Cloud, so if your workflow needs the local filesystem, self-host. For a first integration, Cloud is fine.
• Accounts and API access for whatever you're connecting. For the example: a Google account and a Slack workspace where you can add an app.
• A rough plan. Know your trigger, your transform, and your destination before you open the editor. Five minutes of thinking saves an hour of node-shuffling.

The core concepts you need first

Four ideas carry almost every integration.

Triggers start a workflow. Nothing runs without one. You pick a trigger when you create the workflow, and it sits as the first node. Here are the common types:

The HTTP Request node is the universal adapter. n8n ships hundreds of dedicated app nodes, but when there's no node for the API you need, this one talks to any REST endpoint. Learn it well and you're never blocked by a missing integration.

Credentials are how n8n stores secrets. You never paste an API key into a node field. You create a credential once, n8n keeps it encrypted, and nodes reference it. For the HTTP Request node you'll see generic options like Bearer Token (the most common for modern APIs), Header Auth, Basic Auth, and Query Auth, plus predefined credential types for popular services. Set it once, reuse it everywhere.

Expressions let one node use data from another. Wherever you see a field, you can toggle on expression mode and write {{ }} to pull in live values. Reference the current item's data with {{ $json.email }}, or reach back to a specific named node with {{ $node["Webhook"].json["body"]["name"] }}. Expressions are where static workflows become dynamic ones.

Build it: a webhook to Sheets and Slack integration, step by step

Here's the concrete example. We'll catch a form submission, tidy the data, log it, and notify the team.

1. Create the workflow. From the Workflows tab, click Add workflow. You get a blank canvas asking for a first step.
2. Add the Webhook trigger. Add a Webhook node. Set the method to POST and give it a path. n8n generates two URLs, a test URL and a production URL. Copy the test URL into whatever's sending data (your form tool, or a quick test request).
3. Send a test payload and capture the structure. Click Listen for test event, then trigger your form or fire a sample POST. n8n captures the incoming JSON so the nodes after this can "see" the field names. This step matters: you can't reference data you haven't captured yet.
4. Add an Edit Fields (Set) node to transform. Connect an Edit Fields (Set) node after the webhook. This is where you shape the data: rename messy field names, drop what you don't need, combine values. Create clean output fields like name, email, and submitted_at, mapping each with an expression such as {{ $json.body.name }}. Keeping a tidy shape here makes every downstream node simpler.
5. Create credentials for your destinations. Before wiring the last nodes, set up credentials. For Google Sheets, connect your Google account through n8n's credential flow; for Slack, connect via OAuth or a bot token. Do this once and both nodes will reference these credentials.
6. Add the Google Sheets node to log the row. Connect a Google Sheets node, choose the Append row operation, pick your spreadsheet and sheet, and map each column to your clean fields with expressions like {{ $json.email }}. Now every submission lands as a new row.
7. Add the Slack node to notify. Connect a Slack node set to send a message to a channel. Compose the text with expressions, for example New signup: {{ $json.name }} ({{ $json.email }}). You can wire both the Sheets and Slack nodes off the same Set node so they run in parallel.
8. Test the full path, then activate. Run the workflow end to end and confirm the row appears and the Slack message lands. When it's solid, toggle the workflow to Active. Activating switches the webhook from the test URL to the production URL, so update whatever calls it to use the production address.

That's a complete n8n integration. The shape (trigger, transform, deliver) is the same one I reuse for lead routing, billing alerts, onboarding flows, and most of the AI automation work I ship. Swap the nodes, keep the skeleton.

Common mistakes to avoid

A few traps catch nearly everyone at the start:

• Using the test URL in production. The test URL only listens while you're actively watching for an event. Once the workflow is active, the production URL is the live one. Mixing these up is the most common "why isn't my webhook firing" question.
• Hardcoding secrets in node fields. Always use credentials. Keys pasted into fields leak into exports and shared workflows.
• Skipping the transform step. Sending raw webhook payloads straight to a destination works until the source changes one field name. An Edit Fields (Set) node in the middle gives you one clean place to adapt.
• No error handling. Real integrations need a plan for when an API is down or a record is malformed. Look into error workflows and retry settings before you depend on something in production.
• Not testing with real data. A payload you typed by hand rarely matches what the source actually sends. Capture a genuine event early.

Next steps

Once your first integration works, the natural progressions are: add an IF node to branch on conditions, batch and loop over multiple items, call an LLM mid-workflow to classify or summarize, and build proper error handling around anything that matters. The concepts don't change. You're still wiring triggers, transforms, credentials, and expressions, just in richer combinations. If calling an LLM is your next step, my ChatGPT automation guide for n8n walks through the OpenAI node setup and the guardrails that matter.

If you want to see what production-grade automations look like, I keep a set of live demos you can poke at. And if you'd rather have someone build or audit the integration for you, I work as an n8n consultant and I'm Top Rated Plus on Upwork, with a 100% Job Success Score across 80+ jobs. Book a 30-minute call and tell me what you're trying to connect.