A practical look at how Make can move content, notifications, approvals, and AI outputs through your training workflow with less manual effort.
Let me get right to the point: Make is not a beginner friendly product in the way people pretend or want it to be. Yes, it is visual. Yes, it is little to no code. Yes, it can do amazing things once you understand it. But visual does not automatically mean intuitive, and that was absolutely my experience. I am a highly visual builder. I like systems. I like design. I like seeing moving parts laid out in front of me. So I expected Make to click for me faster than it did. It did not.
What slowed me down most was understanding what Make actually needed from one module to the next. The numbered outputs. The relays. The mapping. The “why is this token available here but not there?” feeling. The “why did this scenario run, but not the way I thought it would?” feeling. That part took real time. And honestly, I needed help from Chet to get through the early learning curve. A lot of help. Not because Make is bad. Because Make is one of those tools where the power only really shows up after you understand how it wants you to think.
That is the first truth I would tell any learning team looking at it: expect ramp up time. If you already have somebody on staff who knows Make, great. If you plan to hire for it, even better. But if you think a smart, creative person can just open it and start building clean scenarios on day one, I would not count on that. Not unless they are unusually patient or unusually stubborn. Once it starts clicking, you begin to see why people love it. But at the beginning, for me, it felt less like magic and more like learning the wiring diagram behind a control room.
That matters, because I do not want to oversell this kind of tool. Make can absolutely move content, notifications, approvals, records, and AI outputs through a workflow with less manual effort. But before it becomes a throughput engine, it is going to ask you to learn its language and pay it's price.
For learning teams, especially the ones that are already overloaded, throughput matters more than people admit. We talk about strategy. We talk about quality. We talk about learner impact. All of that matters. But in the middle of the real workday, somebody still has to move assets, send notices, route approvals, collect updates, and keep the whole thing from stalling out in email hell. Make lives in that middle layer.
Now that I understand it better, Make feels like building the pipes between the tools you already use and the decisions your team already makes. At first, though, it felt like trying to read a subway map designed by engineers who assumed I already knew the city. That is the part I appreciate. It is visual enough to stay approachable, but still powerful enough to handle real workflow logic. It lets you stop thinking in isolated tasks and start thinking in connected events. A form gets submitted. A scenario starts. A branch checks a value. A notification fires. A record gets created. A file gets moved. An AI step generates output. A human reviews. Then the next action happens without somebody manually pushing the whole thing uphill.
Training teams do a shocking amount of manual coordination.
Content requests come in from one place. Review comments live somewhere else. Project status is tracked in another tool. Assets sit in folders. Notifications happen in email. AI outputs land in chat threads. Approval decisions happen in meetings. Then somebody has to connect all of it and pretend the process is under control.
That somebody usually becomes the workflow. That is not scale. That is hero mode. Make gives you a chance to replace hero mode with actual process.
A request comes in. You do not want it stuck in inbox purgatory. Make can take form submissions, CRM entries, spreadsheet rows, or app triggers and immediately turn them into tracked work. Create the record. Assign an owner. Notify the right person. Stamp the date. Move the file. Kick off the next step.
This is one of the most obvious wins. Draft ready for SME review? Notify them. No response after a set time? Follow up. Approval granted? Move the project to the next stage. Rejected? Route it back with the notes attached. A lot of teams say they have a review process. What they really have is memory and good intentions. Make can turn that into a real path.
This is where it gets especially interesting now. AI can generate content quickly, but AI outputs are only useful if they go somewhere structured. Make can take generated summaries, scripts, notes, or data and route them into documents, spreadsheets, project trackers, messages, or approval queues. That matters because raw AI speed without workflow support just creates a bigger pile faster.
I am not talking about noisy alerts for the sake of feeling active. I mean useful notices. “Your review is ready.” “This file failed.” “This status changed.” “This record needs approval.” “This learner data set updated.” Small moments. Big cumulative impact.
This is the part people often underestimate. Rename files. Move assets. Update records. Sync statuses. Add a timestamp. Append notes. Keep one system from drifting too far away from another. That is not glamorous work, but it is the kind of work that silently eats hours across a month.
As someone who has lived in code and markup for a long time, I have a healthy suspicion of visual builders. Some are too simple to matter. Some become spaghetti the minute you try anything real.
Make lands in a more interesting place. You can see the flow. You can explain the flow. You can show someone else the flow. That matters in team environments where not everybody wants to read script logic just to understand why a notification got sent.
It also means you can start with something smaller, prove the value, and then build outward. That is usually the right move with automation anyway.
The danger with no code automation is thinking the lack of code means the lack of complexity.
That is never true for long.
You are still designing logic. You are still defining conditions. You are still dealing with dependencies, edge cases, naming, sequence, permissions, and failure points. Make may lower the barrier to building automation, but it does not erase the need for system thinking.
That is why I do not look at Make as “easy.” I look at it as accessible architecture.
One of the first mindset shifts I had with Make was realizing the real value is not just a single automation. It is a sequence of small connected automations that reduce handoffs across a process.
That is where throughput shows up.
One scenario captures the request. Another routes the review. Another writes the approved output to the right destination. Another sends the notification. Another updates the tracking record. None of them alone looks revolutionary. Together they change how work moves.
That is the part I think learning teams should care about most.
AI gets all the headlines. Workflow deserves more of them.
If AI generates a course outline, then what? If an assistant writes a draft email, then what? If a model turns meeting notes into action items, then what? If it produces a script, transcript, or analysis, then what?
Without workflow, the answer is usually “a person copies it somewhere and hopes the next step happens.”
Make is one of the tools that can answer “then what?” in a useful way.
That is why I think it belongs in serious AI conversations. Not because it is flashy. Because it turns output into motion.
I would not start with one giant “automate everything” fantasy board.
That is how people create pretty chaos.
I would start with one ugly recurring pain point that everybody already complains about. Missed handoffs. Review bottlenecks. Content request confusion. File movement. Broken follow up. Pick one. Fix it. Show the time savings. Then grow from there.
Automation adoption is much easier when the first win is obvious.
In a strange way, Make reminds me of the project manager every team wishes they had. Not the kind who schedules more meetings. The kind who quietly keeps the work moving, remembers the handoffs, nudges the right people, files the right things, and never forgets the next step.
That is a useful role for software to play.
Especially in training and development, where a lot of good work gets delayed not because the team lacks skill, but because the workflow between skilled people is too loose.
I do not see Make as the star of the show. I see it as the stage crew that makes the show actually happen on time.
And that is a compliment.
Because some of the most valuable tools are not the ones screaming for attention. They are the ones quietly reducing friction behind the scenes, making your better tools look smarter and your human talent look more organized.
That is exactly what Make can do if you build with intention.
Make is one of the better looking tools in the stack. As a visonary, that may actually be why I respect it.
It is practical. It is visual. It is operational. And for learning teams that need more throughput without adding more hand carried admin work, it can be a very real lever.
I think that is the key word here: throughput.
Not just output. Not just ideas. Not just more drafts. Actual movement.
Because in the real world, value is not created when a great idea exists. Value is created when the right thing moves to the right person at the right time and the process does not collapse in the middle.
