# Make Academy > Free, public learning resources for the Make automation platform. Covers scenarios, modules, AI agents, custom apps, and best practices for building automations on Make. ## Make Basics: Modules > Your first chapter of Make Basics. Learn what modules are, how they relate to apps, and how each category — search, action, trigger, universal, and built-in (Flow Control, Tools, Text Parser) — is used in real scenarios. - [Introduction to modules](https://academy-content.make.com/courses/make-basics-modules/01-introduction-to-modules): In this introductory unit, you will learn more information about modules in Make. - [Search modules](https://academy-content.make.com/courses/make-basics-modules/02-search-modules): In the previous unit, you learned about the different categories of modules in Make. - [Action modules](https://academy-content.make.com/courses/make-basics-modules/03-action-modules): In the previous unit, you learned about search modules in Make, and created a scenario with a search module. - [Trigger modules](https://academy-content.make.com/courses/make-basics-modules/04-trigger-modules): Previously, you learned about search modules and action modules in Make. - [Scheduling your scenario](https://academy-content.make.com/courses/make-basics-modules/05-scheduling-your-scenario): Now it's time to explore another Make feature: scenario scheduling. It allows you to manage the time periods of the scenario execution. ## Make Basics: Data > Data is what scenarios move around. This chapter covers how modules pass data to each other, how mapping works, and how to handle collections and structured data in Make. - [Brief introduction to Data](https://academy-content.make.com/courses/make-basics-data/01-brief-introduction-to-data): In this introductory unit you will explore the data types in Make. - [Introduction to Collections and Arrays](https://academy-content.make.com/courses/make-basics-data/02-introduction-to-collections-and-arrays): Within this unit you will explore Collections and Arrays. - [How to map data](https://academy-content.make.com/courses/make-basics-data/03-how-to-map-data): You are now at the third unit of the second course within Make Basics. - [Data structures](https://academy-content.make.com/courses/make-basics-data/04-data-structures): In this short piece of content, you will: discover what are data structures learn how this relates to data types * understand how data structures are created ## Make Basics: Functions > Functions let you reshape data on the fly. This chapter walks through introducing functions and then transforming text, dates, numbers, and averages in your scenarios. - [Introducing functions](https://academy-content.make.com/courses/make-basics-functions/01-introducing-functions): For example: Transform text to upper / lower case Transform an item's date based on your location / preference * Transform numerical data, such as calculating the average of multiple values - [Transforming Data - Text](https://academy-content.make.com/courses/make-basics-functions/02-transforming-data-text): You are now at the second unit of the "Transforming data using functions" course within Make Basics. - [Transforming Data - formatDate](https://academy-content.make.com/courses/make-basics-functions/03-transforming-data-formatdate): Before you continue, make sure you've completed the exercise in unit 1 of this course. - [Transforming Data - Average](https://academy-content.make.com/courses/make-basics-functions/04-transforming-data-average): You are now at the fourth unit of the "Transforming data using functions" course of Make Basics. - [Transforming Data - formatNumber](https://academy-content.make.com/courses/make-basics-functions/05-transforming-data-formatnumber): The last function that you are going to explore in this course is formatNumber(). ## Make Basics: Aggregators > Aggregators turn many bundles into one. This chapter introduces aggregator modules and shows numeric and text aggregators in action. - [Introducing Aggregators](https://academy-content.make.com/courses/make-basics-aggregators/01-introducing-aggregators): Put simply, aggregation is the process of combining multiple values into a single value. - [Numeric Aggregators in action](https://academy-content.make.com/courses/make-basics-aggregators/02-numeric-aggregators-in-action): You are now at the second unit of the "An Introduction to Aggregators" course within Make Basics. - [Text Aggregators in action](https://academy-content.make.com/courses/make-basics-aggregators/03-text-aggregators-in-action): You will also be introduced to the Tools → Set variable module. ## Make Foundation: Scenarios > Hands-on foundations for building Make scenarios. Covers the scenario UI, what an app is, configuring modules, connecting them, and mapping data between them. - [Scenario UI](https://academy-content.make.com/courses/make-foundation-scenarios/01-scenario-ui): We are happy to see you here, ready to start your automation journey and further your skill set with Make. - [Renaming saving and organizing](https://academy-content.make.com/courses/make-foundation-scenarios/02-renaming-saving-and-organising): Let's explore the following steps and create a scenario. Please complete each stage of this exercise. - [What is an app](https://academy-content.make.com/courses/make-foundation-scenarios/03-what-is-an-app): While following this unit, ensure that you have your Make Foundation Use Case open. - [Configuring a Module](https://academy-content.make.com/courses/make-foundation-scenarios/04-configuring-a-module): While reviewing this content, ensure that you have your Make Foundation Use Case open. You will be adding more to it in this session! - [Connecting Modules](https://academy-content.make.com/courses/make-foundation-scenarios/05-connecting-modules): You are now way past the halfway point of the first course, and quickly starting to approach running your scenario for the first time. Before you get there, you have a few more bits to learn. - [Introduction to Mapping](https://academy-content.make.com/courses/make-foundation-scenarios/06-introduction-to-mapping): The aim of this unit is to map items from one module to another. ## Make Foundation: Routing and Filters > Routers split your scenario into multiple paths, filters keep only the data you care about, and scheduling decides when scenarios actually run. - [Adding a router](https://academy-content.make.com/courses/make-foundation-routing-filters/01-adding-a-router): The aim of this course is to add more steps to the scenario you already created, so you can advance your knowledge and understanding of Make. In this unit you'll do that by adding a router. - [Adding a filter](https://academy-content.make.com/courses/make-foundation-routing-filters/02-adding-a-filter): You will notice that your scenario is really starting to expand. In the previous unit, you learned how to implement a router into your scenario. - [More options with filters](https://academy-content.make.com/courses/make-foundation-routing-filters/03-more-options-with-filters): The aim for this unit is: explore the AND / OR option within filters. - [Overview of scheduling](https://academy-content.make.com/courses/make-foundation-routing-filters/04-overview-of-scheduling): The following units will be focused on other elements that you need to know in Make. - [Run once](https://academy-content.make.com/courses/make-foundation-routing-filters/05-run-once): At this point you've created a scenario, learned about modules, mapped some content, and even added filters. ## Make Foundation: Operations and Credits > Every Make scenario consumes operations, and operations consume credits. This chapter explains the model and shows how to keep your scenarios efficient. - [Introduction to Operations and Credits](https://academy-content.make.com/courses/make-foundation-operations-credits/01-introduction-to-operations-and-credits): The goal for this course is to further delve into operations, credits, bundles and scenario scheduling within Make. - [Credit consumption in Make](https://academy-content.make.com/courses/make-foundation-operations-credits/02-credit-consumption-in-make): In the previous unit, you learned the basics of operations, credits, and how to track your credit use. Now, you'll take a closer look at how credit counting works in real scenarios. - [Introduction to Bundles](https://academy-content.make.com/courses/make-foundation-operations-credits/03-introduction-to-bundles): You'll see the term bundle a lot while building your scenarios, so it's useful to define it. A bundle is a single package of data that moves through your scenario when it runs. - [Using credits effectively in scenarios](https://academy-content.make.com/courses/make-foundation-operations-credits/05-using-credits-effectively-in-scenarios): So far, you've explored how operations and credits work in Make, and examined the various scheduling options available for your scenarios. ## Make Foundation: Organization > How to run Make at a team level — organization settings, team roles and dashboards, and using templates to scale your library of scenarios. - [My Organization](https://academy-content.make.com/courses/make-foundation-organization/01-my-organization): The aim of this course is to provide an overview of the Make user interface, and a few important bits that are worth knowing before you continue your automation journey. - [Org - user settings](https://academy-content.make.com/courses/make-foundation-organization/02-org-user-settings): You are now at the second unit of the "Make UI" course within the Make Foundation. - [Team dashboard and roles](https://academy-content.make.com/courses/make-foundation-organization/03-team-dashboard-and-roles): You are now at the third unit of the “Make UI” course within the Make Foundation. - [Templates](https://academy-content.make.com/courses/make-foundation-organization/04-templates): Templates are pre-built scenarios that can be used at any time to automate specific tasks and processes. ## Make Intermediate: JSON and Arrays > JSON is the lingua franca of automation. This chapter shows how to bring JSON into Make, iterate over arrays one item at a time, and aggregate items back into a single result. - [Importing JSON into a scenario](https://academy-content.make.com/courses/make-intermediate-json-arrays/01-importing-json-into-a-scenario): Let's make a start on exploring a new set of concepts, shall we? - [Iterating an array into bundles](https://academy-content.make.com/courses/make-intermediate-json-arrays/02-iterating-an-array-into-bundles): You are now at the second unit of the "Introduction to iterators and array aggregators" course within the Make Intermediate learning path. - [Aggregating an array from bundles](https://academy-content.make.com/courses/make-intermediate-json-arrays/03-aggregating-an-array-from-bundles): This unit will introduce a new tool - the array aggregator. ## Make Intermediate: get() and map() > get() reaches into nested data, map() reshapes arrays. This chapter explains both, then shows the get(map()) pattern that solves a huge class of real automation problems. - [Get() function](https://academy-content.make.com/courses/make-intermediate-get-map/01-get-function): In the first unit, you will learn how to retrieve (get) values from an array and a collection using the get() function. - [The map() function](https://academy-content.make.com/courses/make-intermediate-get-map/02-the-map-function): Let's build on the knowledge from unit 1. You've looked at the get() function, which returns a value from an array. - [get() and map()](https://academy-content.make.com/courses/make-intermediate-get-map/03-get-and-map): In the previous two units, you have learned how to use the get() and map() functions and what you can achieve with each of them. - [The get(map)) use case](https://academy-content.make.com/courses/make-intermediate-get-map/04-the-get-map-use-case): This last unit will explore a use case that focuses on the two functions covered in this course, how they operate individually and combined. ## Make Intermediate: HTTP > When Make doesn't have a dedicated app, the HTTP module bridges the gap. Covers the basics of HTTP, GET and POST requests, and chaining HTTP modules into webhooks. - [Introduction to HTTP](https://academy-content.make.com/courses/make-intermediate-http/01-introduction-to-http): This unit is theory based, meaning that you don't need to build any scenarios at this point. - [HTTP GET](https://academy-content.make.com/courses/make-intermediate-http/02-http-get): You are now at the second unit of the "Introduction to HTTP" course within Make Intermediate. - [HTTP POST](https://academy-content.make.com/courses/make-intermediate-http/03-http-post): By the end of this unit you will understand how to: use the POST request method create your own scenario using a POST request * create your very first webhook / data structure - [HTTP to webhook](https://academy-content.make.com/courses/make-intermediate-http/04-http-to-webhook): Webhooks are a method of receiving notifications that an event has happened from another application or scenario, as soon as it happens. ## Make Intermediate: Webhooks > Webhooks let external systems push data into Make as it happens. Covers the webhook model, the iterator + aggregator pattern, exchanging data, and managing webhook queues. - [What are webhooks](https://academy-content.make.com/courses/make-intermediate-webhooks/01-what-are-webhooks): You might remember that in the last course we briefly touched on webhooks. - [Exchanging data with webhooks: GET requests](https://academy-content.make.com/courses/make-intermediate-webhooks/02-exchanging-data-with-webhooks-get-requests): In the previous unit you have expanded your knowledge on what webhooks are and how they can be used within Make. - [Exchanging data with webhooks: POST requests](https://academy-content.make.com/courses/make-intermediate-webhooks/03-exchanging-data-with-webhooks-post-requests): In the previous unit you have seen how data can be sent when calling your webhook, and you have focused on query parameters and the GET request. - [Scenarios and webhook queues](https://academy-content.make.com/courses/make-intermediate-webhooks/04-scenarios-and-webhook-queues): In this last unit you will learn more about: how webhook scenarios are triggered different types of triggers scheduling configurations webhook queue - [Iterator and Aggregator](https://academy-content.make.com/courses/make-intermediate-webhooks/05-iterator-and-aggregator): This unit is theory-based. We will explore a couple of different use cases using Make. ## Make Intermediate: Errors > Things break. This chapter walks through Make's error model, how to deliberately generate errors for testing, what incomplete executions are, and how to attach error handlers. - [Errors in Make](https://academy-content.make.com/courses/make-intermediate-errors/01-errors-in-make): This unit helps you build a strong foundation in understanding errors in Make. You will learn: what are errors in Make which errors you can encounter * how errors impact your scenarios - [Generate an error](https://academy-content.make.com/courses/make-intermediate-errors/02-generate-an-error): Fail again. Fail better. As architect Samuel Beckett wisely said. - [Incomplete executions](https://academy-content.make.com/courses/make-intermediate-errors/03-incomplete-executions): In the previous unit, you created a scenario with an error. Now it's time to learn how to fix it. - [Error handlers](https://academy-content.make.com/courses/make-intermediate-errors/04-error-handlers): You have reached the final unit of the Handling errors in Make course! ## Make Intermediate: Advanced Functions > Past the basics — date/time transformations, conditional logic functions, and converting between strings and arrays. - [Transforming date and time](https://academy-content.make.com/courses/make-intermediate-advanced-functions/01-transforming-date-and-time): Whether you're working with a team across different time zones or not, you'll hopefully come across something useful here! - [Conditional functions](https://academy-content.make.com/courses/make-intermediate-advanced-functions/02-conditional-functions): what is a conditional function how to use the if(), ifempty(), switch() and contains() functions * how functions can help make your scenarios be more maintainable and save credits - [String and array conversion: Part 1](https://academy-content.make.com/courses/make-intermediate-advanced-functions/03-string-and-array-conversion-part-1): You'll start by spreading the functions in multiple modules to see how each one works, but at the end, you'll see how to join these functions together and optimize your scenario. - [String and array conversion: Part 2](https://academy-content.make.com/courses/make-intermediate-advanced-functions/04-string-and-array-conversion-part-2): Of course, some cases are unique and some of these other functions will be covered in more detail in later courses. You might also need to make use of other functions, so explore away if you'd like. ## Getting Started with Custom Apps > A guided tour of Make's app system. Explains the role of APIs, when to build a custom app, and the tools Make provides to build one. - [APIs and Make](https://academy-content.make.com/courses/custom-apps/01-apis-and-make): In Make, this is much easier. Make offers apps that integrate with third-party services, using modules to call their specific API endpoints. - [Testing your custom app](https://academy-content.make.com/courses/custom-apps/02-testing-your-custom-app): If you have never built a custom app before or never thought about it, you're in the right place! ## Intro to AI > A foundational tour of AI for automation builders. Covers core concepts, generative AI, and where AI fits in the broader landscape of automation types. - [Intro to AI](https://academy-content.make.com/courses/intro-to-ai/01-intro-to-ai): the different categories that compose AI and their applications - [Generative AI](https://academy-content.make.com/courses/intro-to-ai/02-generative-ai): Generative AI or GenAI is a category of artificial intelligence that creates new content, such as text, images, audio, and video. - [Types of automation](https://academy-content.make.com/courses/intro-to-ai/03-types-of-automation): So far, you’ve gathered a lot of information about what AI agents are and how they work. Now, the time has come to start exploring AI agents in ## Large Language Models > A deep dive into Large Language Models — what they are, how to prompt them, and the practical limits and risks you should know before putting them into production. - [What are LLMs](https://academy-content.make.com/courses/large-language-models/01-what-are-llms): In the previous course, you learned about AI: what it is and how it learns. You have also started to learn about generative AI (GenAI). - [Interacting with LLMs](https://academy-content.make.com/courses/large-language-models/02-interacting-with-llms): You have reached the second unit of the Mastering LLMs course! - [Limitations and risks of LLMs](https://academy-content.make.com/courses/large-language-models/03-limitations-and-risks-of-llms): In the previous units, you have explored LLMs and learned how to interact with them to achieve the desired results. ## AI Agents Foundations > Conceptual foundations for AI agents — their architecture, their reasoning loop, and how agentic automation reshapes what scenarios can do. - [What are AI agents](https://academy-content.make.com/courses/ai-agents-foundations/01-what-are-ai-agents): what AI agents can do Get ready, your exploration is about to begin! - [How do AI agents work](https://academy-content.make.com/courses/ai-agents-foundations/02-how-do-ai-agents-work): Now that you know what AI agents are, it's time to explore how they actually work. - [Agentic automation](https://academy-content.make.com/courses/ai-agents-foundations/03-agentic-automation): You have just learned about the three types of automation in Make, now it's time to focus on agentic automation. ## AI Automation in Make > Practical lessons on using AI inside Make scenarios — from picking an AI provider to using Make AI Toolkit, AI Content Extractor, and third-party AI apps. - [Get started with AI in Make](https://academy-content.make.com/courses/ai-automation/01-get-started-with-ai-in-make): In the previous courses, you have learned the basics of AI, LLMs, and GenAI. Now it is time to use AI in Make. In this unit, you will learn: - [Make AI toolkit and Make AI content extractor](https://academy-content.make.com/courses/ai-automation/02-make-ai-toolkit-and-make-ai-content-extractor): You will learn: how Make AI Toolkit and Make AI Content Extractor work - [Build your scenarios using AI](https://academy-content.make.com/courses/ai-automation/03-build-your-scenarios-using-ai): In the previous unit you have learned what you can do with AI in Make. Now it's time to use AI in your scenarios. ## Building AI Agents with Make > Hands-on guidance for the Make AI Agent module — from your first agent to multi-tool, multi-step automations. - [Make AI agent](https://academy-content.make.com/courses/build-ai-agents-with-make/01-make-ai-agent): You are at the fourth unit of the course AI agents for beginners. - [Build an AI agent with Make](https://academy-content.make.com/courses/build-ai-agents-with-make/02-build-an-ai-agent-with-make): After all of this theory, it's time to see everything in action! ## Context Engineering > Context is what an agent sees when it reasons. This course covers system prompts, conversation management, and how to feed agents the data they need from files and tools. - [Giving context to your AI agent](https://academy-content.make.com/courses/context-engineering/01-giving-context-to-your-ai-agent): how prompts and tools definitions impact your AI agents' behavior - [Managing conversations](https://academy-content.make.com/courses/context-engineering/02-managing-conversations): This unit focuses on how AI agents manage and remember conversations. - [AI agents and files](https://academy-content.make.com/courses/context-engineering/03-ai-agents-and-files): If you're wondering how your AI agent can process and work with files, you're in the right place. ## Agent Engineering > A practical engineering process for designing AI agents: how to plan an agent's role, how to build it step by step, and how to harden it for real use. - [Planning the AI agent](https://academy-content.make.com/courses/agent-engineering/01-planning-the-ai-agent): You are at the first unit of the course Design and build a production-ready AI agent. - [Building](https://academy-content.make.com/courses/agent-engineering/02-building): You are on the second unit of the course Design and build a production- ready AI agent. - [Agent engineering](https://academy-content.make.com/courses/agent-engineering/03-agent-engineering): You are at the final unit of the course Design and build a production-ready AI agent. ## Optimizing AI Agents > Advanced techniques for production AI agents — picking the right model, tuning tool definitions, calibrating behavior, and thinking through security. - [Tool optimization](https://academy-content.make.com/courses/optimizing-ai-agents/01-tool-optimization): This unit teaches you to optimize tools for your AI agents and apply best practices to make the most out of your tools. - [Calibrating your AI agent](https://academy-content.make.com/courses/optimizing-ai-agents/02-calibrating-your-ai-agent): The context window holds everything your AI agent needs to work: your system prompt, context files, tool definitions, tool inputs and outputs, and conversation history. - [Model choice and advanced settings](https://academy-content.make.com/courses/optimizing-ai-agents/03-model-choice-and-advanced-settings): In unit 1, you learned best practices for configuring and optimizing your AI agent's tools. - [Security considerations](https://academy-content.make.com/courses/optimizing-ai-agents/04-security-considerations): In the previous unit, you learned how to give knowledge to your AI agent. Now let's explore the security considerations you need to address when building agents and providing them with knowledge. ## Model Context Protocol (MCP) > MCP is the emerging protocol for connecting AI agents to tools and context. This course covers the protocol, Make's MCP client, and how to publish your own MCP server from Make. - [What is MCP](https://academy-content.make.com/courses/mcp/01-what-is-mcp): Now, translate this to the world of AI agents. An AI agent needs tools to complete its tasks. - [Make MCP client](https://academy-content.make.com/courses/mcp/02-make-mcp-client): In the previous unit, you've learned the theory of MCP. Now it's time to see how this works in Make, starting with the Make MCP client. - [Make MCP server](https://academy-content.make.com/courses/mcp/03-make-mcp-server): You have just learned about Make MCP client. Now, let's look at the MCP server.