MySQL for Developers
Introduction to schema

The importance of schema design in database performance

Before we dive into query optimization, indexes, and other fun stuff, let's take a step back and talk about an often overlooked aspect of database performance: schema design. Schema refers to the structure of your database tables, including column types, sizes, and attributes. Your schema can either set you up for success or cause problems down the road, so it's important to get it right from the start.

Writing a schema

When it comes to creating your schema, you have two options: write the definitions by hand or let your framework generate them. While both methods are valid, letting your framework generate the schema can save you some time and effort. However, it's important to remember that you are still ultimately responsible for the schema, regardless of how it's created.

MySQL offers a variety of data types, and we'll cover most of them in detail later on. But before we do, it's important to keep three guiding principles in mind when choosing a data type:

  1. Pick the smallest data type that will hold all of your data
  2. Pick the simplest column type that accurately reflects your data (e.g. use a numeric type for numbers, not a string)
  3. Ensure your schema accurately reflects the reality of your data (e.g. don't make a non-nullable column nullable)

By following these principles, you can create a compact and efficient schema that accurately reflects your data.

Why schema design matters

You may be thinking, "disks are cheap, why does compactness matter?" While it's true that disks are relatively inexpensive, compactness can improve database performance in several ways:

  • Faster data access: The more compact your schema is, the faster the database can access the data. This is because the database doesn't need to spend extra time searching for the data within larger column types.
  • Efficient indexing: When it comes time to create indexes, a compact schema can improve index speed and efficiency. This is because indexes are stored in memory, and a smaller schema means less memory usage.

In other words, optimizing your schema isn't about minimizing disk space usage, but rather enabling the database to access and index your data more efficiently.

Common data types

Now that we know why schema design matters, let's take a closer look at some of the most common data types in MySQL:

  • INT: Used for integer values
  • FLOAT and DOUBLE: Used for decimal or floating point values
  • VARCHAR: Used for variable-length character strings
  • DATE, DATETIME, and TIMESTAMP: Used for date and time values

When choosing a data type, it's important to consider your data and choose the simplest and smallest type that accurately represents it. For example, if you're storing ages, you may choose an INT type rather than a VARCHAR type, as integer values are simpler and more compact.


While schema design may not be the most glamorous aspect of database development, it's a crucial one that can significantly impact your database's performance. By following the three guiding principles of compactness, simplicity, and accuracy, you can create a schema that effectively reflects your data and enables fast data access and indexing.

About this lesson

Building efficient and compact tables set us up for success in every other area. Here we'll look at a few guidelines for good schemas.

Closed captioned

Meet your instructor, Aaron Francis

Developer Educator at PlanetScale

I’m a dad to one-year-old twins and a software developer with a keen interest in processes and automation.

Feedback or questions? Reach out to our team at

By submitting your email, you agree to the processing of your personal information by PlanetScale as described in the Privacy Policy.