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.