If you cannot quickly and cheaply build a machine learning model that works, you will be stuck in a cycle of writing complex code from scratch, burning money on compute time, and failing your MLS-C01 exam. Amazon SageMaker's built-in algorithms and AutoML exist to rescue you from that nightmare. They let you generate accurate predictions using pre-built, Amazon-tested mathematical recipes, without needing a PhD in statistics or the ability to write a custom neural network from scratch.
Jump to a section
A simple way to picture Amazon SageMaker Built-in Algorithms and AutoML
You have exactly 20 minutes to bake a cake for a friend's birthday. You are not a professional baker. You have two options: Option A is to measure out flour, sugar, eggs, baking powder, and butter from scratch, carefully mix them in the right order, and hope the oven temperature is correct. Option B is to buy a box of instant cake mix. The box already contains the exact blend of dry ingredients for a reliable vanilla sponge. You just add a few wet ingredients (like eggs and oil), stir, pour into a tin, and bake. The result is a consistent, edible cake in a fraction of the time, with almost no chance of disaster.
Amazon SageMaker's built-in algorithms are those pre-measured boxes of cake mix. Each algorithm (like XGBoost for predictions, or BlazingText for language) contains a pre-optimised mathematical recipe that has been tested by Amazon's engineers on thousands of datasets. You do not need to know the underlying calculus or programming to make it work. You simply point the algorithm at your data, and it learns the patterns. AutoML, in this analogy, is the ultimate automated kitchen robot. You dump in a pile of raw ingredients (your data), press a button labelled 'Find the best recipe', and the robot tries dozens of different cake mixes (algorithms) simultaneously. It then selects the one that produced the fluffiest cake (the highest accuracy) and hands it to you with a bow on top. Both tools exist for the same reason amateur bakers exist: you want a good result without needing a culinary degree.
Machine learning (ML) sounds intimidating, but at its core, it is simply teaching a computer to find patterns in data. Think of a standard algorithm as a fixed set of instructions, like a recipe for making tea: boil water, add tea bag, wait three minutes. A machine learning algorithm is different: it is a recipe that learns from examples. You feed it thousands of examples of 'good' and 'bad' outcomes, and it adjusts its internal rules until it can make its own decisions on new, unseen data.
Amazon SageMaker is a fully managed service from Amazon Web Services (AWS) that provides every tool you need to build, train, and deploy ML models in the cloud. The term 'fully managed' means AWS handles the underlying infrastructure (servers, storage, networking) so you can focus on the model itself. Within SageMaker, there are two major tools for beginners: Built-in Algorithms and AutoML (officially called SageMaker Autopilot).
Built-in Algorithms are pre-built mathematical recipes optimised by Amazon's engineers. They cover the most common ML tasks. When you use a built-in algorithm, you do not need to write any algorithm code yourself. You only need to prepare your data (usually a CSV file or a table) and tell SageMaker which algorithm to use.
Here are the key built-in algorithms you must know for the exam:
XGBoost – This is the most popular algorithm for tabular data (data in rows and columns, like an Excel spreadsheet). It is excellent for both classification (predicting a category, like 'will this customer buy? Yes/No') and regression (predicting a number, like the price of a house). Think of it as a supercharged decision tree that learns from its own mistakes.
Linear Learner – A simpler algorithm for tabular data. It assumes a straight-line relationship between your input numbers and your target. It is fast and works well when the relationship is indeed linear.
BlazingText – Designed for text data. It can analyse the sentiment of a review (positive or negative), classify documents, or find similar words. It is a faster version of the popular 'Word2Vec' algorithm.
Image Classification (ResNet) – Used for images. You give it thousands of labelled pictures of cats and dogs, and it learns to tell them apart. ResNet is a specific type of deep neural network architecture that pioneered 'residual learning'.
Object Detection – Goes one step further than image classification. It not only tells you an object is in the image, but it also draws a box around it. Think of a self-driving car identifying pedestrians and road signs.
Semantic Segmentation – Paints every single pixel in an image with a label. For example, in a satellite photo, it can colour every road pixel grey, every tree pixel green, and every building pixel red.
K-Means – An unsupervised learning algorithm. It does not need labelled data. It looks at your data and automatically groups similar items together. Example: grouping customers into 'budget shoppers', 'luxury buyers', and 'bargain hunters' based purely on their spending habits.
Principal Component Analysis (PCA) – Reduces the number of columns in your dataset while trying to keep the most important information. It is used to simplify data and speed up other algorithms.
AutoML (SageMaker Autopilot) is a different beast. You do not choose an algorithm. You give Autopilot your dataset and tell it what column to predict. Autopilot then automatically tries many different algorithms (including XGBoost, Linear Learner, and deep learning models), tunes their settings (called hyperparameters), and compares their performance. When it finishes, it presents you with the best model and a human-readable report (a notebook) explaining how it arrived at that decision. Autopilot is the 'set and forget' option for beginners or for when you do not have time to manually test a dozen approaches.
Both tools exist because building ML models from scratch is hard and time-consuming. The vast majority of real-world problems do not require a custom algorithm. Reusing a proven, pre-built algorithm is like using a textbook formula instead of re-deriving calculus every time you want to calculate an area. It saves time, money, and prevents common mistakes.
Prepare Your Data and Store It in Amazon S3
Your data must be in a format SageMaker can read, usually CSV or RecordIO protobuf. The data is uploaded to an S3 bucket (a virtual storage container). This is the first physical step because SageMaker cannot access your laptop's local files. The exam asks you to identify the correct storage location and format.
Choose or Configure an Algorithm
If you are using a built-in algorithm, you select it by name from the SageMaker console or via SDK code. You must also set the 'problem type' (classification or regression). If you are using Autopilot, you skip this step because Autopilot chooses algorithms for you based on the target column type. The exam tests your ability to distinguish when to choose manually versus when to use Autopilot.
Specify Hyperparameters
For built-in algorithms, you set hyperparameters like 'num_round' (number of trees in XGBoost) or 'learning_rate'. These settings control how the algorithm learns. For Autopilot, you do not set hyperparameters; Autopilot tunes them automatically across many trials. The exam loves to ask which hyperparameters are relevant for a specific algorithm.
Start a Training Job
A training job is a request to SageMaker to run the algorithm on your data. SageMaker spins up one or more virtual servers (called compute instances), loads your data from S3, runs the algorithm, and saves the resulting model file back to S3. You are charged for the time these servers run. This is the core execution step that the exam tests in terms of resource requirements and instance types.
Evaluate the Model's Performance
After training, SageMaker reports metrics like accuracy, F1 score, or mean squared error. You check these metrics to see if the model is good enough. If using Autopilot, it ranks the best candidates automatically. If using a built-in algorithm manually, you must compare results yourself. The exam expects you to interpret which metric is appropriate for a given problem.
Deploy the Model to an Endpoint
Deploying creates a real-time endpoint (a web service) that can accept new data and return predictions. SageMaker handles the underlying server setup. You can then call the endpoint from any application using HTTP requests. The exam tests the difference between a 'batch transform' (one-time predictions on a big dataset) and a 'real-time endpoint' (ongoing predictions).
Meet Priya, a data analyst at a mid-sized UK e-commerce company called ShopFast. Her boss wants her to build a model that predicts whether a customer will churn (stop buying) in the next month. Priya has never written a single line of Python before. She needs a result within two days.
Priya logs into the AWS Management Console and navigates to Amazon SageMaker. She has a CSV file with 50,000 rows of customer data: how many times they logged in, how much they spent last month, how many support tickets they opened, and their loyalty tier. The column she wants to predict is called 'churned' (yes or no).
Step 1: Launch a notebook. Priya opens SageMaker Studio, the visual interface for SageMaker. She creates a notebook instance, which is essentially a virtual computer in the cloud that runs Jupyter notebooks (interactive coding documents). She uploads her CSV file to the virtual hard drive (called Amazon S3 in AWS).
Step 2: Start Autopilot. Instead of coding, she goes to the 'Autopilot' section in SageMaker Studio. She clicks 'Create experiment'. She selects the location of her CSV file in S3, tells Autopilot which column is the target ('churned'), and chooses whether to run a 'classification' (yes/no) or 'regression' (number) problem. She selects classification.
Step 3: Autopilot runs. Autopilot automatically splits her data into a training set (80% of the rows) and a validation set (20% of the rows). It then starts nine different model candidates simultaneously. It tries XGBoost with different settings, Linear Learner, and other algorithms. For each candidate, it tracks a performance metric called 'accuracy' (what percentage of customers did it correctly predict).
Step 4: Review the result. Two hours later, Autopilot sends Priya an email. She looks at the results. The best model achieved 94% accuracy using a specific variant of XGBoost. Autopilot also generated a Jupyter notebook that shows the exact code used. Priya does not need to understand the code; she just needs the model.
Step 5: Deploy the model. Priya clicks 'Deploy model' in the Autopilot interface. SageMaker automatically creates a real-time endpoint (a web address the company's systems can call with new customer data). She writes a simple script that sends a new customer's data to this endpoint, and the endpoint returns 'churn: yes' or 'churn: no' instantly.
What did Priya 'actually' do? She did not write any ML code. She prepared a CSV file, clicked a few buttons in a web console, waited, and then deployed a model. The underlying complexity (distributed computing, hyperparameter tuning, model versioning) was hidden by SageMaker. This is the reality of using built-in algorithms and AutoML in a business context: the IT professional's job shifts from coding to data preparation, interpretation of results, and deployment management. The exam tests whether you understand the 'glue' between these steps: how to configure the data source, which algorithms to pick for which data type, and how to deploy without writing custom inference code.
The MLS-C01 exam has a clear obsession with two things: (1) matching the correct built-in algorithm to the right data type and problem, and (2) understanding what Autopilot does versus what you must do manually. Here is exactly what they test.
Exam Topic 1: Algorithm Matching The examiner will describe a business problem and ask you to choose the best built-in algorithm. The trap is that people memorise names without understanding the data type. - You will see a question like: 'A company wants to automatically group customer emails by topic into 5 categories. The emails are already labelled with the correct topic. What algorithm should they use?' The correct answer is BlazingText (multi-class classification on text data). The trap is choosing K-Means (which is unsupervised and would not use the labels). - Another popular trap: giving you a dataset of house prices with 20 columns (square footage, number of bedrooms, etc.) and asking for the best algorithm. The correct answer is usually XGBoost (best for structured, tabular regression). The trap is Linear Learner (which could work but is less accurate for complex patterns). The exam loves XGBoost and expects you to default to it for tabular data.
Exam Topic 2: Autopilot Capabilities They test exactly what Autopilot does behind the scenes. Key facts to memorise:
Autopilot automatically runs multiple algorithms in parallel (not sequentially).
Autopilot automatically tunes hyperparameters (it does not just pick default values).
Autopilot generates a report notebook that shows the code it used (this is a differentiator from just a black box).
Autopilot cannot handle every data type. It works best with tabular (CSV) data and is not designed for raw image files or audio files.
Exam Topic 3: Built-in Algorithm Limitations They love to ask what a built-in algorithm cannot do. For example:
Built-in algorithms are not customisable at the algorithmic level. You cannot change the fundamental math inside XGBoost. If you need a completely new algorithm, you must bring your own script (BYOS) using the SageMaker SDK.
Built-in algorithms are optimised for certain instance types (the virtual server hardware). For example, algorithms that handle tabular data (like XGBoost) are optimised for CPU instances, not GPU instances. The exam may ask you to choose the correct instance family.
Exam Topic 4: Autopilot vs. Built-in Algorithm Workflow A common multi-step question describes a scenario where a data scientist has already selected an algorithm. They ask you what the next step is. The answer typically involves bringing the data into SageMaker in the correct format (RecordIO protobuf or CSV) and storing it in Amazon S3.
Key Definitions to Memorise for the Exam:
'Training job' – the process of running an algorithm on data inside SageMaker. It is a resource you pay for by the second.
'Hyperparameter' – a setting you configure before training starts (e.g., learning rate, number of trees). Autopilot tunes these automatically; manual algorithms require you to set them.
'Endpoint' – the URL SageMaker creates so you can send new data to your trained model for predictions (inference).
'Bring Your Own Model (BYOM)' – when you skip built-in algorithms and upload your own pre-trained model file (like a TensorFlow model) to SageMaker for deployment. The exam will contrast this with using built-in algorithms.
'Amazon SageMaker Canvas' – a no-code visual interface that uses AutoML under the hood. It is for business analysts, not data scientists. The exam may try to confuse you by asking if Canvas is for ML engineers (it is not).
Trap Pattern: The 'Exact Same' Trap The exam will present two algorithms that seem interchangeable (e.g., Linear Learner and XGBoost) and ask which one is 'more suitable'. The right answer hinges on a single clue in the question: if the data has 'non-linear relationships' or 'complex interactions', XGBoost is correct. If the question says 'baseline model' or 'simple and fast', Linear Learner is correct. Autopilot is correct when the problem says 'automatically select the best algorithm' or 'the team has limited ML experience'.
Use XGBoost as your default built-in algorithm for tabular (structured) data with predictions like 'yes/no' or a number.
Use BlazingText for text classification tasks like analysing customer reviews or sorting emails into categories.
Use Image Classification (ResNet) when your input data is a set of labelled images and you want to assign a single label to each image.
SageMaker Autopilot automatically tries multiple algorithms in parallel, tunes their hyperparameters, and returns the best model plus a report notebook.
AutoML does not replace the need for data cleaning; you must still prepare your CSV file by handling missing values and removing irrelevant columns.
Built-in algorithms are pre-optimised and production-ready; you do not need a PhD to use them effectively for most business problems.
On the exam, always match the algorithm to the data type first (tabular, text, image), then match the problem type (classification, regression, clustering).
Autopilot generates a candidate definition notebook that shows you the exact code used, proving it is not a fully opaque black box.
These come up on the exam all the time. Here's how to tell them apart.
Built-in Algorithm (Manual)
You manually select one algorithm (e.g., XGBoost) based on your data type.
You must manually set hyperparameters like learning rate and number of trees.
Best when you know exactly which algorithm is appropriate for your problem.
SageMaker Autopilot
Autopilot automatically tests multiple algorithms (e.g., XGBoost, Linear Learner) at once.
Autopilot automatically tunes hyperparameters across many trials.
Best when you are unsure which algorithm works best or have limited ML experience.
XGBoost
Handles non-linear relationships between features automatically using decision trees.
Generally produces higher accuracy on complex tabular data with many interacting features.
Takes longer to train because it builds many trees sequentially.
Linear Learner
Assumes a linear relationship between input features and the target variable.
Faster to train and simpler to interpret, but often less accurate for complex patterns.
Used as a baseline or when data shows a clear linear trend.
Real-Time Endpoint
Provides low-latency predictions (milliseconds) for individual requests one at a time.
Stays running continuously, so you pay for uptime even when idle.
Ideal for interactive applications like a website recommending products in real time.
Batch Transform
Processes a large dataset all at once, generating predictions for every row in a file.
Starts, runs, and stops automatically, so you only pay for the compute time used.
Ideal for offline tasks like generating monthly churn predictions for all customers.
Image Classification (ResNet)
Assigns a single label to an entire image (e.g., 'this is a cat').
Outputs a class label and a confidence score for the whole image.
Simpler algorithm that does not identify the location of objects within the image.
Object Detection
Identifies multiple objects in an image and draws bounding boxes around each one.
Outputs class labels, confidence scores, and coordinates for each bounding box.
More complex algorithm used for tasks like counting cars in a parking lot photo.
Mistake
Built-in algorithms are only for beginners and are never used in production.
Correct
Built-in algorithms like XGBoost are used in production by large enterprises because they are highly optimised and battle-tested. Using them is not a sign of incompetence; it is a sign of efficiency.
Beginners often think that 'real' machine learning requires writing custom code from scratch. In reality, most production problems are solved with standard algorithms, and custom code is reserved for research or highly unusual problems.
Mistake
AutoML replaces the need for any data preparation or understanding.
Correct
AutoML only automates algorithm selection and hyperparameter tuning. You still need to clean data (fix missing values, remove duplicates), choose which columns to include, and understand the problem type (classification vs. regression). AutoML cannot fix garbage data.
The term 'AutoML' sounds like 'automatic everything'. Beginners expect to feed raw, messy data in and get a perfect model out. This leads to disappointment and exam answers where they incorrectly assume Autopilot handles data cleaning.
Mistake
All built-in algorithms work on any type of data (text, images, tables).
Correct
Each built-in algorithm is designed for a specific data type. BlazingText works on text, ResNet works on images, XGBoost works on tabular data. Using the wrong algorithm for your data type will produce nonsense results.
Beginners see a long list of algorithm names and assume they are interchangeable. The exam exploits this by listing a problem with image data and offering BlazingText as a distractor. The mistake comes from not reading the data type carefully.
Mistake
If you use a built-in algorithm, you cannot change any settings at all.
Correct
You can configure hyperparameters for built-in algorithms, such as the number of trees in XGBoost or the learning rate. You just cannot change the underlying mathematical structure of the algorithm itself.
The word 'built-in' implies rigidity to beginners. They think it is a fixed, unchangeable black box. The exam tests this by asking if you can tune hyperparameters on built-in algorithms. The answer is yes, but only within the predefined range.
Mistake
SageMaker Autopilot only tries one algorithm at a time to save money.
Correct
Autopilot tries multiple algorithms in parallel to save time. It is designed to be fast by exploiting parallel computing on multiple virtual machines simultaneously.
Beginners might think 'automatic' means 'slow and sequential' because that is how a human would work. The exam loves to present a scenario where a team needs results quickly and ask if Autopilot is appropriate. The correct answer is yes, because of parallel execution.
Mistake
Once Autopilot creates a model, you cannot see or modify the code behind it.
Correct
Autopilot generates a Jupyter notebook containing all the code it used. You can inspect, edit, and rerun that code manually if you want to tweak the results or learn from the process.
Beginners fear losing control. They worry Autopilot is a 'black box' that hides its internals. The exam explicitly tests this by asking what Autopilot generates as an output. The answer is a candidate definition notebook.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
A built-in algorithm is a pre-written, optimised model provided by Amazon (like XGBoost). A custom algorithm is code you write yourself (in TensorFlow, PyTorch, or scikit-learn) and bring to SageMaker. Use built-in when possible to save time and avoid bugs.
No, Autopilot is primarily designed for tabular data (CSV files with rows and columns). For image or audio data, you must use specialized built-in algorithms (like Image Classification - ResNet) or bring your own custom model.
No, you do not need to set or tune hyperparameters when using Autopilot. Autopilot automatically performs hyperparameter optimisation as part of its process, trying different values to find the best combination.
Yes, you can use built-in algorithms through the SageMaker Studio visual interface, where you point and click to select the algorithm and data. You can also use the low-code SageMaker Canvas tool for a completely no-code experience. However, the exam assumes some basic knowledge of the AWS SDK (a programming interface) as well.
The candidate definition notebook contains the exact Python code Autopilot used to preprocess your data, train the model, and tune hyperparameters. You can inspect this code to understand the process and even rerun it manually with modifications if you wish.
Choose Linear Learner if the question specifies a simple relationship, a baseline model, or the need for fast training. Choose XGBoost if the question mentions complex patterns, non-linear relationships, or if the data has many interacting features. XGBoost is the safer default for tabular data.
You've finished Amazon SageMaker Built-in Algorithms and AutoML. Continue through the MLS-C01 study guide to build a complete picture of the exam.
Done with this chapter?