I was drowning in repetitive tasks. Every Monday morning, I'd manually pull data from three different APIs, format it into a report, and post it to our team Slack channel. It took about 20 minutes, but it was the kind of soul-crushing routine that makes you think, "There has to be a better way."
I'd tried Zapier, but I kept hitting limits on the free tier. I looked at Make, but the visual interface felt cluttered and confusing. Then a colleague mentioned n8n—an open-source workflow automation tool that I could self-host for free, with a node-based editor that actually made sense.
I decided to build my Monday morning report as my first real project. Here's exactly how I went from zero to my first working workflow, including the parts where I got stuck.
Setting Up: Cloud vs. Self-Hosted
n8n gives you two paths: their managed Cloud service or self-hosting via Docker/Desktop. For my first experiment, I signed up for the n8n Cloud free trial—no credit card required, and I didn't have to wrestle with Docker just to see if the tool was worth my time. If you're the type who wants full control from day one, you can pull the Docker image (docker run -p 5678:5678 n8nio/n8n) and have it running locally in minutes.
I'd recommend starting on Cloud to learn the ropes, then migrating to self-hosted once you know you're committed. That's exactly what I ended up doing later.
The Canvas: Where It All Happens
When you first open n8n, you're greeted with a clean canvas and a prompt: "Start from Scratch" or choose a template. I clicked "Start from Scratch" and was dropped into the workflow editor.
The canvas is where you build your automation. You add nodes (individual steps), connect them with wires, and data flows from left to right. It's visual, but not in a toy-block way—there's real power under the hood.
Step 1: Adding a Trigger
Every workflow needs a starting point. n8n calls these "triggers." You can either manually hit "Execute Workflow" every time you want to run something (defeating the purpose of automation) or set up a trigger node that fires automatically.
For my Monday report, I needed a Schedule Trigger. Here's what I did:
- Clicked Add first step on the canvas.
- Searched for "Schedule" in the node picker.
- Selected Schedule Trigger.
The node configuration panel opened on the right. I set it up like this:
- Trigger Interval: Weeks
- Weeks Between Triggers: 1
- Trigger on Weekdays: Monday
- Trigger at Hour: 9am
- Trigger at Minute: 0
Closed the panel, and there it was—my first node, sitting on the canvas, ready to fire every Monday at 9 AM.
My first mistake: I initially set the trigger to "Days" with a value of 7, thinking it was the same as weekly. It's not. The "Weeks" option lets you pick a specific weekday, which is what I actually needed. The "Days" option just counts 7 days from whenever you last ran it, which drifts over time.
Step 2: Fetching Data with the NASA Node
The official n8n tutorial uses the NASA node to fetch Astronomy Picture of the Day data, which is a great learning exercise. I followed that path first to understand how nodes work before building my actual workflow.
- Clicked the + button on the right side of the Schedule Trigger node.
- Searched for "NASA" and added the node.
- Selected the APOD (Astronomy Picture of the Day) operation.
This is where I hit my first real learning moment: credentials.
Many API nodes in n8n require authentication. The NASA API is free, but you still need an API key. n8n handles this through a credential system—sensitive information is stored separately from your workflow, so you can share workflows without leaking keys.
To set it up:
- In the NASA node, clicked Credential to connect with → Create New.
- Named it "NASA API Key."
- Pasted my API key (obtained from api.nasa.gov—it takes about 30 seconds to get one).
- Clicked Save.
Then I hit Execute Node to test it. The node lit up green, and I saw the response data in the output panel: the APOD title, explanation, image URL, and metadata. This was the moment n8n clicked for me—seeing real data flow through a node I'd configured myself.
Step 3: Processing Data with Expressions
Raw API data is rarely in the format you need. This is where n8n's expression system comes in.
For my actual Monday report workflow (not the NASA tutorial), I needed to pull data from a REST API, extract specific fields, and format them into a Slack message. The expression syntax uses {{ }} to reference data from previous nodes.
For example, to reference the APOD title from the NASA node in a downstream node, I'd write:
{{ $json.title }}
The $json refers to the incoming data item. If you're not sure what fields are available, n8n shows you the data structure from previous nodes right in the expression editor—no guessing required.
My second mistake: I tried to reference data using {{$node["NASA"].json.title}}—the old syntax. It worked, but n8n has moved to the cleaner $json syntax for current-node references. The old syntax still works for cross-node references, but stick with the newer convention when possible.
Step 4: Adding Logic with the IF Node
Real workflows need branching logic. In my report workflow, I only wanted to send a Slack notification if certain conditions were met (e.g., if there were new items to report).
The IF node (now called Switch in newer versions for more complex branching) lets you route data conditionally. I set mine to check:
{{ $json.count }} > 0
If true, the data flows down the "true" branch to my Slack node. If false, the workflow simply ends—no pointless notifications.
Step 5: Connecting to Slack
The final piece was posting to Slack. I added a Slack node, created a credential using a Bot User OAuth Token from my Slack app, and composed my message using expressions to inject the dynamic data:
📋 Weekly Report - {{ $json.date }}
New items found: {{ $json.count }}
Summary: {{ $json.summary }}
I tested each node individually as I built the workflow. This is critical—n8n lets you execute a single node without running the entire chain, which makes debugging much less painful.
Practical Tips I Learned the Hard Way
Test incrementally. Don't build a 10-node workflow and then run it all at once. Build one node, test it, confirm the output, then add the next. This saved me hours of confusion.
Name your nodes clearly. "HTTP Request1" and "HTTP Request2" become meaningless fast. I rename every node to something descriptive like "Fetch Weekly Metrics" or "Filter Active Users."
Watch the data tab. Every node shows its input and output data. When something breaks (and it will), this is your first diagnostic tool. Click the node, check what came in vs. what went out, and you'll usually spot the problem.
Use the pinned data feature. You can "pin" output data on a node so it doesn't re-execute during testing. This is a lifesaver when you're debugging node 8 of a workflow and don't want to re-fetch data from the API every time.
Honest Limitations
n8n isn't perfect. The error handling could be more robust—there's no built-in retry logic with exponential backoff on individual nodes (you have to build it manually). The mobile experience is essentially non-existent; this is a desktop tool. And while the node library is extensive, I've occasionally found myself falling back to the HTTP Request node for services without dedicated integrations.
The expression language can also get unwieldy for complex transformations. If you need heavy data manipulation, consider using a Code node (JavaScript) instead of chaining multiple expression-based nodes.
Where I Landed
That first Monday report workflow has been running for four months without a hitch. I've since built a dozen more—webhook handlers, email parsers, database syncs—and I migrated from Cloud to a self-hosted instance running on a $5/month VPS.
n8n hit the sweet spot for me: powerful enough to handle real automation, visual enough that I can show non-technical teammates what a workflow does, and open-source enough that I'm not locked into someone else's pricing model.
Start small. Build something that saves you 5 minutes this week. Then build something that saves you an hour next month. That's how n8n wins you over—one tedious task at a time.