Make training, 1-on-1.Your work runs on its own.
A Make expert opens your account with you and builds what you need: scenarios (triggers and actions), modules and 2000+ app connections, routers, iterators, filters, error handling, webhooks, API and AI modules. We start from your real case, not theory.
★★★★★ 4.7/5 · 300+ pros trained · France Num certified
ActiveCampaign
Adalo
AdCreative.ai
Ahref
Airtable
Allo (The Mobile First Company)
Anthropic
Apify
Apollo.io
AttioAttio Implementation Partner
Base44
Baserow
Brevo
Bright Data
Browse AI
Bubble
CaptainData
ChatGPT
Claude
Claude CodeClaude CoworkClaude Design
Clay
Clickup
Cursor
DeepSeek
Dust
ElevenLabs
Fillout
Flutterflow
Folk CRM
Folk Implementation Partner
Freepik Spaces
Gamma
GeminiWe build Make scenarios for real clients, not just in theory.
Most Make trainings are run by people who watched two tutorials the night before. At Hack'celeration it's the opposite: multi-step scenarios, connections to 2000+ apps, routers and error handling, that's our daily agency work. Everything we teach you, we practice on shipped projects. We know the traps (the misplaced iterator that blows up your operations count, the webhook that loops) because we've already solved them.
- We build Make scenarios for real clients every week, not just in theory
- 1-on-1 format: the trainer adapts to your level, beginner or seasoned ops
- We tell you when Make isn't the right call (sometimes n8n or a simple Zap is enough)
- We start from your real account and your actual processes, not a dummy example
Four pillars to automate your work with no code.
A poorly handled Make means scenarios that break, an operations count that runs away, processes still done by hand. Most of the trouble comes from the logic, not the tool. We pick up your real account and work through the four pillars together.
- Build scenarios
One trigger, some actions, and it runs on its own
We start from the trigger module, then chain the actions, step by step. Instant trigger on a webhook or scheduled polling every 15 minutes, we pick based on your case. You learn to read a bundle, to test a scenario before you turn it on, and to schedule it so it runs without you touching it. The basics, but set up properly.
Build my first scenario - Modules and 2000+ apps
Connect your whole stack, without writing a line
Make connects more than 2000 apps: Gmail, Airtable, HubSpot, Notion, Slack, Stripe, your CRM. We configure the connections (OAuth, API keys, scopes), wire the modules together and map the fields. And when an app has no dedicated module, we go through the HTTP module. You finish with your stack wired end to end.
See the connections - Routers, iterators, filters
The logic that makes the difference between tools
This is where Make goes past basic automations. Routers to branch into several directions on a condition, iterators to process a list row by row, aggregators to pack it back together, filters to let through only what counts. We work on data mapping and the functions (map, formatDate, ifempty) on your real bundles, not a dummy example.
See the advanced logic - Errors, webhooks, API and AI
Plug Make into your API and its AI modules
A scenario with no error handling breaks at the first hiccup. We set up error handlers (Resume, Rollback, Ignore), retries and fallback routes. We configure your inbound and outbound webhooks, call any API through the HTTP module, and wire in Make's AI modules (OpenAI, Anthropic) to classify, summarize or draft. All of it robust, ready to hold in production.
See errors and API
Meet our trainers, leave with a plan.
Drop your email. We get back to you to connect you with a Hack'celeration-certified trainer: we look at your Make account, spot the processes worth automating, and tell you where to start. No commitment, even if you don't take the training.
- A diagnosis of your processes to automate, in priority order
- The operations count your scenarios will consume
- The right 1-on-1 format for your level and volume
- An honest take: Make or n8n for your case
Your Make program, step by step.
Five steps, no skipping. Each one on your real account, with a clear deliverable. From the first session we build a scenario that runs. By the end, you build and debug your automations without us.
- Step 1 · Account audit
We open your real Make account and spot what to automate
First session, we share your screen and look at your account together. Which processes are you still doing by hand? Do your existing scenarios run or break silently? Are your connections up to date? We list the real workflows worth automating and the ones not worth the effort. You leave with a clear list, in priority order, and the operations count it consumes. No theory, your real account.
- Step 2 · Your first scenario
One trigger, some actions, and your first scenario running
We go after the concrete part: we build your first end-to-end scenario together. Choosing the trigger (instant webhook or scheduled polling), chaining the actions, mapping fields between modules. We test on a real bundle, fix it, then turn it on. You learn to read an execution, to replay an operation and to schedule the scenario so it runs without you. By the end, a workflow of yours is in production.
- Step 3 · Connections and logic
2000+ apps, routers, iterators and data mapping
We wire your stack. OAuth connections and API keys to your 2000+ apps (Airtable, HubSpot, Notion, Slack), the HTTP module when there's no dedicated connector. Then the logic that changes everything: routers to branch on a condition, iterators to process a list, aggregators to pack it back, filters to let through only what's useful. We work on data mapping and the functions on your own data, not a dummy example.
- Step 4 · Errors, API and AI
We make your scenarios robust and wire in AI
This is where your scenarios go from hacky to reliable. We set up error handlers (Resume, Rollback, Ignore), retries and fallback routes so nothing breaks silently. We configure your inbound and outbound webhooks, call external APIs through the HTTP module, and wire in Make's AI modules (OpenAI, Anthropic) to classify a message, summarize a text or draft a reply. Concrete work, tested on your cases.
- Step 5 · Autonomy
You build and debug your scenarios without us
The number one goal: you become autonomous. By the end of the program, you know how to build a scenario, connect an app, route and filter your data, handle errors and read an execution that failed. You no longer need an agency to automate your work. And if you want to delegate later, we also run a Make agency, but that's not the point here.
Why train 1-on-1 with us.
- 300+Pros already trained on automation
More than 300 people have gone through our trainings across France and Europe. Ops teams, marketers, small-business founders. Not vanity numbers: people who built their first Make scenarios and stopped doing by hand what can run on its own.
- 4.7/5Rating across 334 verified reviews
Average rating of 4.7 out of 5, across 334 reviews. We won't promise everything is magic: you have to build your scenarios on your real account. But the 1-on-1 format makes the difference on a tool as visual and dense as Make.
- 1:1A dedicated expert, not a class of 100
You're not a number in a webinar. A trainer opens your real Make account, looks at your scenarios, and works through your actual cases. We schedule sessions around your availability, replays included.
A working agency, recognized by the French State.
Hack'celeration is certified Activateur France Numérique and holds the AI Ambassador title, both granted by France Num to organizations that genuinely drive the digital transformation of companies. On the ground, more than 300 pros trained and a 4.7/5 rating across 334 verified reviews, left by the people who took our programs, not just by the buyer.
- Certified Activateur France Numérique
- AI Ambassador (France Num)
- 300+ pros trained across France and Europe
- 4.7/5 across 334 verified reviews
The questions we get the most.
What is a 1-on-1 Make training?
An individual program with a Make expert, not a class of 100 people. We open your real account, look at your scenarios, and work through your actual cases: triggers, modules, routers, error handling. You ask your questions live, the trainer adapts the pace to your level. We schedule sessions around your availability, and you leave with concrete actions every time. That's what makes the difference on a tool as visual and dense as Make.How much does the Make training cost?
There is no single price. We connect you with a trainer certified by Hack'celeration, matched to your need and your level. It varies from one trainer to another, based on their profile and the format that fits your project.Make or n8n: which one to pick?
It depends on your need. Make is more visual, hosted for you, with more than 2000 apps ready to connect and a fast learning curve. n8n is open source, self-hostable, more flexible on code and often cheaper at high volume, but asks for a bit more technical skill. If you want fast no-code and a huge app catalog, go Make. If you want to self-host and code steps, look at n8n. During the training, we help you decide based on your real case.How do routers and iterators work in Make?
The router sends your scenario in several directions on a condition: a hot lead goes to the CRM, a cold lead to a nurturing list. The iterator takes a list (the rows of a file, the attachments of an email) and processes it item by item, then the aggregator packs the results back. They're what turn a linear automation into a real workflow. In 1-on-1, we set them up on your own data until the logic is crystal clear.Do I need to be technical to take the Make training?
No, not necessarily. Make is built for no-code: you build your scenarios by dragging modules, without writing code. To go further (HTTP module, API calls, mapping functions), a bit of logic helps, but the 1-on-1 format is built exactly for that: we start from your exact level. Beginner, we go step by step. Seasoned ops, we jump straight to routers, error handling and the API. You can run Make visually without ever touching code if you prefer.How many apps can Make connect?
More than 2000 apps with dedicated modules: Gmail, Google Sheets, Airtable, HubSpot, Notion, Slack, Stripe, Shopify, and most of the tools you already use. Each app exposes its actions (create, read, update, delete) and its triggers. And when an app has no module, we go through the HTTP module to call its API directly. In training, we connect your real stack, configure the authentications (OAuth, API keys) and map fields between your tools.How do you handle errors in a Make scenario?
Error handling is what separates a reliable scenario from a hacky one that breaks silently. Make offers error handlers you can attach to each module: Resume to carry on with a fallback value, Rollback to undo everything, Ignore to skip, Break to pause and resume. We add retries for temporary errors (rate limit, timeout) and fallback routes to alert you. In 1-on-1, we make your scenarios robust so they hold in production.Can you use webhooks and the API in Make?
Yes, and it's one of the big parts of the training. Inbound webhooks trigger a scenario in real time the moment an event lands (a Stripe payment, a form submission, a message). Outbound webhooks push your data elsewhere. And the HTTP module calls any REST API, even without a dedicated connector: you handle the headers, the authentication, the request body and the response parsing. We build these flows together on your real cases.Can Make do AI inside my scenarios?
Yes. Make has native AI modules (OpenAI, Anthropic) you wire into any scenario without coding. Classify an incoming email, summarize a long text, extract structured data, draft a reply, score a lead: you pass the data to the AI module, get the result back and chain it with the rest. We configure the prompts, handle the JSON output and connect it to your tools. It's one of the topics we cover in the 4th pillar of the training.Is the training online or in person?
100% online, over video, 1-on-1. You join the sessions from anywhere, we share your screen and your Make account live. Sessions are recorded if you want to revisit them. The individual format means real interaction: you're not a number in a webinar of 100, the trainer answers your questions about your setup and your scenarios. That's what makes learning concrete on a tool as visual as Make.
Your work deserves to run itself. Meet your trainer.
Drop your email. An expert who builds Make scenarios daily looks at your account and shows you how to automate your work. No commitment, even if you don't take the training.