All right. Welcome to the deep dive. This one,
this is really built just for you. You know,
someone who wants to get smarter with this stuff
faster without getting totally swamped. Yeah,
exactly. We're like cutting through the noise.
We are. And today we're diving deep into NEN
automation workflows. But we're going way past
the usual stuff. We're talking about finding
those like hidden tricks, the ones most people
don't even know are there. Right. The kind of
things that can. genuinely level up how you build
automations make a real difference. Oh, for sure.
And we're using this great article as our guide.
It's called 28 NEN Tricks for Automation Workflow
Mastery, Part 1. And yeah, it's pretty dense.
It promises those aha moments. Yeah. I think
it delivers. It really does. So our goal today,
pull out the absolute best, most actionable stuff
from this first part. We want to help you go
from just, you know, using NEN to, well... The
article calls it an automation wizard, which
sounds kind of cool. Yeah, yeah, it does sound
cool. But practically speaking, it's about boosting
your productivity. The article even mentions
maybe being like 10 times more productive. Which
would be amazing. And also building stuff that's,
you know, more solid, more resilient, less likely
to just fall over. Or robust, yeah. exactly handling
things better so this part one covers 28 tricks
kind of breaks down into keyboard shortcuts which
sound basic but trust me they aren't then data
handling organizing your workflows and some uh
more advanced data stuff too it's a really solid
foundation they lay out okay let's jump in then
first section Becoming a keyboard ninja. Ah,
yes. Getting away from the mouse. It seems small,
but honestly, the speed difference is huge. The
source basically says your mouse is in a bottleneck,
like full stop. Totally. And just keeping your
hands on the keyboard. It helps you stay in the
zone, you know. Less context switching. Right.
So the first few are maybe things you know, but
they're essential. Plus and minus for Zoom. You
need that control. Yeah. Basic, but you use it
all the time to either focus in or see the big
picture. But here's where navigation gets really
neat. The instant view adjustments. Like pressing
one, boom, your whole workflow fits on the screen
instantly. Oh that is so handy like just for
like getting your bearings or finding that one
node you lost track of. I use one constantly
and zero is your centers whatever you've got
selected perfectly no more fiddly dragging. Yeah
saves a lot of frustration especially on complex
canvases a real sanity saver. And then node hopping
select a node then just use the arrow keys zip
between connected nodes super fast. Way way quicker
than clicking especially when things are kind
of clustered together and if you hit the rest
Enter on a selected node. Instantly opens the
parameters panel. Love that one. Yep. Quick editing
access. And, you know, the classic Kuti ILE CMD
plus A, select everything for moving big chunks
or copying. Standard shortcut. But yeah, essential
in Andan for managing those larger workflows.
Okay, now for the real speed stuff. The instant
node menu, the tab trick. Man, this might be
my favorite simple one. Forget clicking the big
plus sign. Just hit tab. anywhere yeah and that
node search menu just pops right up cursor blanking
ready to go start typing hit enter bam note added
it shaves off these tiny moments that just add
up like crazy it's one of those things that feels
minor until you start doing it that it feels
massive and the next one builds on it smart connections
select node then hit tab type your next node
hit enter and it automatically connects it just
chains them together that right there is like
the core of building workflows super fast. It
feels really intuitive, you know, like you're
just thinking the workflow into existence. And
for running it, CDRL CMD plus enter, quick workflow
execution. Yep, faster than clicking the button.
Keeps the hands on the keyboard. Speaking of
hands on the keyboard, CTRL CMD plus S save all
the time. It's muscle memory. Yes. The source
really emphasizes this. NEN does autosave, but
hitting save manually creates more fine -grained
recovery points in the history. Yeah. Super important
if, you know, your browser decides to crash.
Okay. Or you just make a mistake, which happens.
Oh, yeah. Been there. That history feature is
a lifesaver. Definitely. Okay. Moving on to pro
selection. directional node selection use shift
plus arrow keys select a node shift plus right
arrow and it grabs that node plus everything
downstream connected to it in that specific path
shift plus left goes upstream it's way more precise
than just dragging a selection box especially
when your workflow gets tangled oh yeah for sure
okay another quick one instant sticky notes shift
plus s then click bam Little note right where
you need it. Super fast. Yeah, just for jotting
down a quick thought or reminder. We'll come
back to making those notes even better later.
Ooh, foreshadowing. Nice. And the last keyboard
one here, deactivate. Activate nodes. The D key.
Select a node. Hit D. And it just grays out.
Gets skipped when the workflow runs. This is
so useful for testing, right? Totally. Test just
one part. Or disable something temporarily. Or
maybe turn off a branch that's giving you trouble
while you figure it out. Just toggle it on and
off super quick. So why fuss over all these keyboard
tricks? The source makes a pretty strong argument.
It's that cumulative time saving, right? On a
workflow with like 20, 30, maybe 50 nodes, the
article suggests it could turn, say, three hours
of clicking into maybe just 30 focused minutes.
That's huge. Yeah. And it keeps you in that flow
state. You're not constantly breaking your concentration,
switching back and forth. It's like learning
to touch type versus hunting and pecking for
your automation building. That's a perfect analogy,
actually. So we've sped up the how, but what
about the what? The data itself. Exactly. Let's
shift gears. Time for some data manipulation
magic. Tricks to understand and shape that data
flow effectively. Taming the data before it tames
you. as the source puts it. I like that. Yeah,
too. First up, the schema preview superpower.
This is seeing the expected data structure before
you run anything. Yeah. For nodes that talk to
known services, think Airtable, OpenAI, Notion,
whatever NA may, can often show you this kind
of grayed out phantom preview in the output panel.
It's what it thinks the data will look like.
And the really cool part, you can actually drag
fields from that phantom preview directly into
your expression editors downstream. This is massive.
You can start building your logic, mapping things
out, before you even make the first real API
call. It saves time, prevents typos because you're
dragging, not typing field names. And saves API
credits. Because you're not running it over and
over just to see the structure. No more guesswork.
It's like having the data blueprint before the
data even arrives. So good. Okay, next. Pin and
edit strategy. Stop wasting those API calls during
testing. This is critical, especially with paid
services like LLMs. Run the node that gets the
data once. Get your output. Then hit P or click
the little pin icon. And that locks in that exact
data for that node. It won't run again when you
test the workflow. It just uses the pin data.
But the real power, like the article says, is
you can click into that pin data and edit the
JSON directly. Yes. simulate anything. What if
a field is missing? What if a value is different?
What if you get an error message? Just type it
into the pin JSON. And then you can test all
your downstream logic, your IF nodes, your error
handling with controlled static data without
making another real ATI call. It's huge for saving
time and money. And it works for trigger nodes,
too. You can run a trigger manually, pin the
output, and then even paste in totally different
JSON to simulate various incoming webhooks or
events. Total simulation power. Yeah. Yeah, this
is such an underrated feature for building robust
workflows. For sure. Okay, one more quick one
in this Davis section. The instant expression
mode shortcut. Just typing. Oh, man, this saves
so many clicks. Seriously. Right. Instead of
click the field, click add expression, then type.
Just type as the very first character in any
field that takes expressions. And boom, you're
instantly in expression mode, ready for your
stuff. Yeah, you can just type hellojson .name
straight away. Keeps you on the keyboard. Saves
countless tiny clicks. So these data tricks,
the schema preview, pin and edit, these shortcut,
they really give you way more flexibility and
confidence when you're building. Totally. You're
working with data in a much more controlled,
predictable, and... Yeah, cost -effective way.
Builds better workflows. Okay, so we're building
faster. We're handling data smarter. What's next?
Keeping it all organized. Avoiding that, you
know, spaghetti monster on the canvas. Workflow
organization is key. Oh, gosh, yes. Trying to
debug a messy workflow. Or hand it off. It's
a nightmare. Good organization makes them maintainable,
scalable, professional, really. First trick here
builds on something earlier, smart sticky notes.
Remember, shift plus S to create one, while the
power up is markdown. Yes. You can use full markdown
formatting inside sticky notes. Headings, bold,
italics, bullet points, numbered lists, even
links. It turns them from simple reminders into
actual little documentation blocks right on the
canvas. You can structure explanations. And the
source even mentions embedding images. If you
host an image somewhere with a direct link, you
can use the .alt .rel markdown to show it right
there. Kind of cool for diagrams or quick visual
references. Definitely. Next up, purposeful color
coding. Apply colors to nodes and sticky notes.
Makes the whole workflow instantly easier to
scan and understand, but... Consistency is key.
You need a system. The article suggests one,
like white for standard stuff, red for critical
actions, yellow for important notes, green for
success points, blue for maybe AI or communication
notes, purple for utilities. But whatever system
you choose, document it. Put a sticky note right
there explaining your color code. Make it functional,
not just pretty. Absolutely. And then note naming.
Seriously, stop leaving nodes as set node 3 or
HTTP request 2. Please, this sounds so basic,
but in a complex flow, it's impossible to know
what's going on otherwise. Set node 3 means nothing.
Get new leads from Facebook ads tells you exactly
what it does. Action plus object is a good formula.
What does it do and what's it doing it to? Your
future self will thank you. Anyone else looking
at it will thank you. And there's a shortcut,
F2. Or function, plus F2. Rename the node right
on the canvas. No need to open the panel, just
make it a habit. Rename it as soon as you know
its purpose. Yes. Okay, next. Workflow history.
The built -in N8 time machine. That little clock
icon, top right. Saved my bacon more than once.
You know, you make some improvements and suddenly
everything's broken. Happens to the best of us.
History shows you a list of saved versions, timestamps
and all. You can restore an old version. Or,
and this is great, you can clone an old version
as a new workflow, perfect for trying stuff out
without risking your working version, like branching.
Yeah, great for experiments. You can also download
the JSON for backup or if you want to compare
versions. The source has this funny bit about
how this feature saves developers from their
own late -night brilliant ideas. Hey, yeah, sounds
about right. Relatable. And remember, CTRL -CMD
plus S saves frequently create more recovery
points in that history. Good reminder. Okay,
last one for organization. Environment variables.
Using UNV. This is about putting configuration
stuff like API URLs, maybe dev versus prod settings,
non -secret tokens outside your workflow in a
central manageable place. It's a huge step up
for maintainability. No more hard coding that
stuff directly in your nodes. Makes workflows
cleaner and easier to move between different
environments. Right. You set these variables
outside on EDA, maybe in Docker or the .env file
or your cloud platform settings, and then you
access them in expressions using... Your variable,
like to one dot APM point plus users. Or sometimes
is variable to weird chars. It just separates
your configuration from your actual automation
logic. Much cleaner. So yeah, organization isn't
just tidying up. It's building professional scalable
blueprints. It really is the foundation for anything
complex or long lasting. Okay, that brings us
to the final section for this part one deep dive.
Advanced data wizardry. Handling the really tricky
stuff. Yeah, complex structures, time -sensitive
data, making sure things don't break, handling
lots of items. First up, J .M. Shah. The article
calls it, like, SQL, but for JSON. Basically,
yeah. If you're wrestling with supernested JSON...
writing those crazy long game. We had json .data
.item .zero .user .profile .contact .things.
JamesPath might be your new best friend. It's
a query language just for JSON, much cleaner
syntax. Yeah. And Mesnaz supports it directly
with JamesPath object expression. The source
gives great examples, like grabbing all emails
from a nested list, leads .interactions .type,
email .email, or filtering and reshaping data,
customers .age26, fullname .name, emailaddress
.email. Wow, okay. That looks way simpler than
trying to code that or use multiple set nodes.
They recommend checking out jamiespath .org to
learn it. Definitely worth it if you deal with
complex JSON a lot. Okay, next, the datetime
context trick. Using no dollar. Giving your workflows
awareness of time, the now object is just there
in expressions, ready to use. It's a lux indeed
time object, which is powerful. So you can easily
get the current timestamp, format dates, get
the day of the week, even do math like adding
seven days. But here's a critical tip from the
source. Check your NAN instances time zone setting.
Yes. in setting general mass time zone. If that's
wrong, now might be UTC or your server's default,
which can totally screw up scheduling or any
logic based on local time. Good catch. Okay,
quick one. Array string transformation using
join and split. Simple but essential. Join separator
turns an array like AB into a string like AB.
Then split separator does the reverse, turns
AB back into AB. Using .join or join in is super
handy for formatting lists nicely, maybe for
feeding into an AI prompt or just creating readable
text output. Very useful. Next, JSON error prevention.
This is about cleaning up user input before you
stick it inside other JSON. Yeah, people type
weird stuff, right? Quotes, new lines, backslashes.
If you just blindly put JSON. dot user input
and the input has a quote your whole json breaks
the fix is using dot replace with regular expressions
to escape those special characters like replacing
hen and you might need to chain them the source
suggests maybe escaping backslashes first then
quotes then replacing literal new lines with
the end character sequence you got to be careful
before embedding raw input into json strings
yeah the example was like input from a webhook
you absolutely have to sanitize that before putting
it in say an http request body that needs to
be valid JSON. It prevents a lot of weird, hard
-to -debug errors. OK, next, binary data handling,
working with files, PDFs, images, et cetera,
the stuff under the binary property. Right. And
the problem is nodes like set might accidentally
drop that binary data if you're not careful how
you connect things. Yeah, the next node might
get the file name, JSON part, but the actual
file content, binary part, disappears. Solution
one, the recommended one, use the merge node.
Exactly. You feed the node with the binary data.
like from a download node, into one input of
the merge node and maybe a set node with metadata
into the other input. The merge node intelligently
combines them, making sure both JSON and binary
properties survive in the output item. Solution
two is the code node, but the source says it's
more advanced and can be tricky. You have to
manually return an object containing both properties.
Merge is usually the way to go. The main idea
is just be aware that intermediate nodes might
drop the binary data unless you explicitly preserve
it. Usually with merge. Gotcha. Okay. Trick 27
marked as new. Item index. This pops up inside
nodes that loop through lists. Right. It just
gives you the number, the zero -based index of
the item currently being processed in the loop.
Which gives you really useful context inside
that loop. Yeah. Think about naming files sequentially.
Invoice item index plus one dot PDF. Or maybe
doing something different for the first five
items. I have index five. Or alternating actions
based on even odd index. super handy oh i can
definitely see uses for that and the final trick
for part one number 28 also new the traffic controller
split in batches node this is all about dealing
with api rate limits ah yeah the classic problem
you have 500 things to send to an api but it
only allows say 10 requests per second connect
an http request directly and boom errors everywhere
so the solution take your list of 500 items feed
it into the split in batches node first Tell
it to break the list into smaller chunks, maybe
batches of 10 in this case. Then process each
batch, like with your HTTP request node, and
crucially, after processing the batch, add a
wait node. Exactly. Wait for maybe a second or
two. This throttles your requests, keeps you
under the API limit, prevents errors, makes you
a good API citizen, and it even helps NAN manage
memory better with large lists. That seems absolutely
essential for any kind of bulk processing against
external services. Totally. It makes those kinds
of workflows actually reliable. Wow. Okay, that's...
That's a lot. That's the 28 tricks from part
one of the article. Yeah, we covered the keyboard
speed stuff, the data handling magic, keeping
things organized, and then some pretty powerful
advanced data techniques. And they really are
foundational, aren't they? Like even just picking
up a few of these could genuinely save hours
and prevent a ton of headaches. It lets you build
much more capable, scalable automations. And
yeah, the article hints there's more in part
two. Right. They mentioned things like HTTP security
deep dives, error handling patterns, advanced
workflow designs, even a mastery plan. But yeah.
That's for another time. For sure. These 28 alone
give you a massive toolkit to work with already.
So, yeah, we went from navigating faster to understanding
and controlling data to organizing workflows
like a pro and finally into some serious data
wizardry. And remember, these aren't just like
tiny optimizations. They can fundamentally change
how you approach building an Antidot, unlocking
stuff you might not have thought possible before.
Absolutely. So the challenge to you is just pick
one. Or two, try the tab trick for adding nodes
or start naming your nodes properly every time.
Just try it out in your next project. Start small,
feel the difference, and then maybe layer in
another trick next time. Build that muscle memory.
Exactly. So here's a final thought to leave you
with. Mastering these kinds of detailed shortcuts
and techniques, it obviously makes you faster.
But does it also change the kind of problems
you feel confident tackling? Think about it.
What workflow felt maybe too complex, too messy,
too difficult to manage before that you could
potentially design and maintain now using some
of these tricks? That's a really good question.
It definitely expands the possibilities, doesn't
it? It really does. Well, thanks for joining
us on this deep dive into NAPEN tricks. Yeah.
Thanks for listening. Keep automating.