No-Code 101: Data Structures

This post is part two of the No-Code 101 series, a quick start, no nonsense guide to nontechnical people to learn how to build automations and AI agents without learning to code.

If you’ve ever used Excel, you already understand data structures—you just didn’t know it. If you want to learn how to build stuff with no-code, there are a few ideas you should know. One of those ideas is how to organize data.

Data structures are just organized boxes for your data.

When you build stuff with n8n (or any other no-code tool) the most common “box” you’ll need to use is called JSON (JavaScript Object Notation).

It’s basically a suitcase of data: it holds your data in a way that’s easy to pack, unpack, and ship between apps.

When we send data in n8n or between apps, we call that a payload. To build on our previous post about node-based thinking, this payload travels between nodes.

What’s inside a JSON?

JSON can hold a few components that are relatively easy to remember:

• Key-value pairs: Like labeling luggage tags. Key is the label, value is what you wrote on it.
  Example: "name": "Lisa", "email": "lisa@example.com"
• Lists: Ordered collections, like a packing list.
  Example: ["coffee", "laptop", "notebook"]
• Nested JSONS: JSONception: JSONs inside JSONs (e.g., an address with its own street and city). This nested nature is what makes JSON superior to spreadsheets or even Airtable.

{
  "user": {
    "name": "Lisa",
    "hobbies": ["reading", "hiking"],
    "address": {
      "street": "123 Main St",
      "city": "Brooklyn"
    }
  }
}

Tables vs. JSON vs. CSV: What’s the Difference?

1. Tables (Excel/Google Sheets/Airtable):

   • Rows = records (e.g., a row for each customer).

   • Columns = fields (e.g., Name, Email).

   • Tables are rigid: No nesting or other fancy structures

2. JSON:

   • A flexible table that can travel between apps (APIs, no-code tools).

   • Handles nested data (e.g., orders inside a customer profile).

   • Used everywhere in n8n for moving data between steps.

3. CSV:

   • A simplified, row-based table that’s easy to export/import (e.g., from Excel).

   • No nesting—just rows and columns. Great for bulk uploads.

You should know

1. Structure = Labels + Containers

• Labels matter: JSON uses keys (like column headers) to tell apps what the data is.
• Containers organize: Use lists for multiple items (e.g., order history) and objects (curly braces {}) for grouped data (e.g., user profiles).

Example:
In n8n, if a step returns JSON like {"order_id": 456, "items": ["book", "pen"]}, you can easily reference order_id in the next step.

2. Flexibility > Perfection

• JSON doesn’t care if data is messy. One entry can have 5 fields, another can have 3.
• Unlike Excel, you don’t need to predefine columns. Add/remove keys as you go.

Pro tip: Use JSON for dynamic data (e.g., survey responses), and CSV for static lists (e.g., email newsletters).

3. Storage: Where to Park Your Data

• JSON is temporary: It’s great for moving data between apps, but not for long-term storage.
• Use a database: Like Supabase (a simpler, free alternative to Firebase).

What’s Supabase?

• A no-code-friendly database that stores data in tables, but lets you work with JSON-like flexibility.
• Example: Store user profiles with nested JSON (e.g., orders array inside a users table).
• It’s free tier is generous, and it connects seamlessly to n8n.

How to Apply This in n8n

1. JSON is your workflow’s middleman:

   • When moving data from Gmail to Google Sheets, n8n will often format it as JSON.

   • Use the “JSON” node to modify/extract data (e.g., grab order_total from a JSON payload).

2. CSV for bulk actions:

   • Export your Sheets data as CSV, then use n8n’s “CSV” node to parse it into JSON for APIs.

3. Supabase for storage:

   • Set up a projects table in Supabase.

   • Use n8n’s Supabase node to add/update rows (e.g., log new form submissions).

Handle JSON with AI

Here’s a little trick that alone saved me 100 hours of thinking in the last 3 months.

Use GPT-4o-mini to create or modify JSON: When you’re unsure about how the JSON should be created, or you kind of know what you want but don’t know how to make it happen, don’t worry. Just send the payload to a “Basic LLM Chain” in n8n, and configure it the following way:

1. Click on “Require Specific Output Format”:

2. Then you’ll need to add a Model. Doesn’t really matter which model you use, I like to use GPT-4o-mini because it’s so cheap it’s basically free. One thing to remember is to always set temperature to 0.

This is because low temperature will make your responses consistent.

3. Then you’ll also need to add an “Output Parser”.

Here select “Auto-fixing Output Parser”, and add a model. You’ll see that now you need to select an Output Parser again. But this time, you select “Structured Output Parser”.

4. The last thing to do is configure the “Structured Output Parser”. This means you’ll need to give a valid JSON example to the model. Don’t worry, you don’t need to do any of that yourself. Here’s what you can do. Let’s say we have a voice memo transcript like this:

Uh, so I need to grab, um, a dozen eggs—no, scratch that, I mean fresh eggs—milk, and oh, bread. Also, I was thinking, um, orange juice? Or, err, maybe not—oh wait, I definitely need it, right? And then there’s, uh, butter—oh, no, not butter, I mean margarine? Ugh, I’m not sure, but it’s on the list somehow.

Then, there’s fruit—I think I said bananas, or was it apples? Actually, maybe both, if I can’t decide. And, um, cereal… or maybe oatmeal? I’m a bit confused here, so just, err, double-check later. Yeah, that’s probably it for now.

Let’s say we want to turn this into a structured list we need to buy. I’ll just send a simple prompt to ChatGPT like “turn this into a valid JSON”:

The end result is what I need to copy/paste into the Structured Output Parser as an example. In our example this is what we got:

{
  "shopping_list": {
    "eggs": "fresh",
    "milk": true,
    "bread": true,
    "orange_juice": true,
    "margarine": true,
    "fruit": ["bananas", "apples"],
    "grains": ["cereal", "oatmeal"]
  },
  "notes": "Double-check whether cereal or oatmeal is preferred."
}

Here’s how it looks like in action. The below workflow uses AI to generate a draft response to every email I receive in Gmail. You don’t necessarily need this GPT-based parsing for Gmail because it already sends a well structured JSON, but the example is sufficient.

What this will do is it will take your inputs which can be a total gibberish unstructured text and it will try to use GPT-4o-mini to parse it into a valid JSON so I can send it off to:

• an AI agent to process
• save directly to a database
• send to a todo app or any other apps

TL;DR for Non-Developers

• JSON = Your data’s suitcase.
• CSV = A basic spreadsheet for simple lists.
• Supabase = Where you “save” your JSON data long-term.

Still confused? Here’s a cheat sheet:

• Need to move data? Use JSON.
• Need to upload 1000 emails? Use CSV.
• Need to store user profiles? Use Supabase.

👉 Try Supabase here (It’s free, and I’m not paid to say this).

You don’t need to be a developer to “get” data structures. You just need to know:

1. Label your data (keys in JSON, columns in CSV).
2. Choose the right container (JSON for flexibility, tables for simplicity).
3. Store it where you can find it (Supabase > your laptop’s Downloads folder).

Now go automate something or try my Lumberjack Tutor for Data Structures. It’s a free AI tutor that works as a custom GPT that will help you understand data structures better.