Stop Relying on MediaQuery for Sizing in Flutter! Here's What to Use Instead

MediaQuery is not the best tool for responsive design in Flutter. Actually, it's far from it.

I know, it’s tempting to scale widgets based on the percentage of screen size and call it a day. But using MediaQuery for sizing, while seemingly simple, is a slippery slope that often leads to weird and problematic layouts.

Unfortunately, many beginners fall into the trap of using fractional sizing because it seems like an easy solution at first.

But if you’re serious about creating responsive apps, it’s time to reconsider how you approach this.

What is Fractional Sizing?

Fractional sizing means sizing UI elements by a fraction of the screen size.

It’s like saying, “I’ll make this button take up 20% of the screen width, no matter what the actual size is.”

Flutter's MediaQuery is the go-to for this kind of approach. Because it provides access to the screen size through MediaQuery.sizeOf(context) and MediaQuery.of(context).size.

For example, you might use code like this:

Container(
  width: MediaQuery.of(context).size.width * 0.2, // or MediaQuery.sizeOf(context).width
  child: Text('Click me!'),
)

It might seem practical—the button size changes depending on the device. But here’s where it gets messy.

Why Fractional Sizing Hurts Your Layouts

The problem is that fractional sizing often leads to a rigid, uninspired layout that doesn’t fully take advantage of each device’s strengths.

Responsiveness isn’t just about making an app fit into the available space—it’s about making your UI adapt to each device's strengths and weaknesses.

By using fractional sizing, you’re essentially making everything fit within the available space, but at the cost of meaningful adaptability. For example, look at this image:

Image from [ping’s notes](https://notes.tst.sh/flutter/media-query/#wouldnt-text-look-too-small-on-large-screens)

Bigger displays allow a larger field of view for the user. Don’t ditch that by just scaling your text up and calling it a day. Let larger screens breathe with more content or features.

Here's a better layout for the tablet:

Image from [ping’s notes](https://notes.tst.sh/flutter/media-query/#wouldnt-text-look-too-small-on-large-screens)

The key point is: what fits great on a small phone might feel unnecessarily large or cramped on a tablet or desktop.

Widgets may occupy a smaller fraction of the screen, but larger displays give more real estate—so why not take advantage of it?

You Don't Need Your Text to Be Bigger

You don't need to size your font based on the screen size. For example:

Image from [ping’s notes](https://notes.tst.sh/flutter/media-query/#wouldnt-text-look-too-small-on-large-screens)

It is noticeable that the text is as visible to the tablet user as it is for the smartphone user. It's perfectly fine to use static values for font sizes.

A responsive layout shouldn’t just be resized—it should reorganize and realign itself to make the most out of each device's capabilities.

Overflow Errors? Not If You Manage Your Constraints Right

Now, you might be thinking, "If I don't size elements based on device size, won’t I run into overflow issues?"

Overflow errors are less about using fractional sizing and more about not respecting the given constraints.

The real secret to avoiding overflow isn’t about scaling elements—it’s about managing constraints effectively.

When you’re working with Rows or Columns, use Flexible or Expanded to ensure children adjust to the space allowed by their parent widgets. Flutter's built-in layout widgets are great for managing how much space each child takes.

Take a look at this example:

Row(
  children: [
    Flexible(
      child: Container(color: Colors.blue),
    ),
    Flexible(
      child: Container(color: Colors.red),
    ),
  ],
)

With Flexible, the children are set to adjust their size based on the available space, ensuring they fill the Row without causing overflow issues. This way, you can avoid common layout problems while letting Flutter handle the details.

Conclusion

To sum it up: responsiveness is about adapting your layout to the strengths of each device—not just making everything look the same.

Avoid the pitfalls of fractional sizing with MediaQuery and, instead, let Flutter's layout widgets do the heavy lifting. Trust your constraints, leverage Flexible and Expanded, and design with LayoutBuilder to create adaptive UIs.

The next time you find yourself reaching for MediaQuery to scale your widgets, take a step back. Think: is this making the most of the device's characteristics, or am I just trying to make everything look identical? Start building layouts that respect the user’s device, and your apps will be better for it.

What’s holding you back from ditching fractional sizing today? Give it a go—your users (and future self) will thank you.