How to Scale in Figma: Resize with Precision

Figma puts a resize handle on every object, and it also has a separate Scale tool that plenty of people never touch. The handle stretches width and height. Nothing else moves, so a 2px border stays 2px and an 8px corner stays 8px no matter how large the shape gets. Press K instead and stroke weight, corner radius, font size, and effects all travel with the size.

It gets used on single layers, on groups, and on messy multi-selects where nested frames need to grow together instead of stretching into something lopsided.

Figma’s own S-1 filing puts the platform at more than 13 million monthly active users as of March 2025. That number covers designers, PMs, and engineers. A file changes hands several times before anything ships, and everyone touching it depends on the same proportional resize behavior holding up.

What Is the Scale Tool in Figma?

Every property tied to a selection changes at once, not just its width and height. Stroke weight, corner radius, font size, and effects move together instead of the bounding box stretching while everything inside it sits unchanged.

Press K to turn it on. The dropdown next to the move tool in the toolbar lists it as Scale if you’d rather click.

Anyone who keeps a list of Figma keyboard shortcuts pinned to a second monitor just hits K without thinking about it.

Corner handles are not the same thing, and Figma’s own guidance is blunt about it: use the scale tool, not the corner handles, whenever text and strokes need to resize together (Figma Help Center).

The tool sits in the same toolbar group as the frame and shape tools. It works on top of whatever constraints or Auto Layout rules the object already carries, without overriding any of them.

What Are the Ways to Input a Scale Value in Figma?

A scale value can come from a percentage field, from typed pixel dimensions, from dragging the bounding box, or from a math expression. Speed and precision trade against each other, so it depends on whether you’re eyeballing a resize or hitting an exact number.

Figma’s dimension fields accept math, which is the part most people never stumble onto. Percentage, addition, subtraction, multiplication, division, all typed straight in. Put \*1.5 in the width field and the object grows by half its current size, in the same box where you’d normally type 240 (Figma Help Center, 2024).

I still catch myself holding Shift on a plain resize handle out of habit. It locks the aspect ratio, fine, but it skips stroke and corner radius exactly like any other unassisted drag.

What Properties Change When You Scale an Object in Figma?

Stroke weight, corner radius, font size, effects, and the spacing values sitting inside the object. All of it moves when you scale with K, and that’s the whole difference between a real scale and a drag on a handle.

• Stroke weight grows with the shape, so a 2px border lands around 3px at 150 percent
• Corner radius curves adjust to the new size
• Font size goes wherever the container holding the text goes
• Shadows and blurs scale with the layer
• Gaps and padding inside nested groups move proportionally

Vector networks handle this cleanly, since anchor points and path handles move in proportion with everything else in the selection.

Auto-width text resizes cleanly with the shape around it. Text in a fixed box is less predictable, because the frame holds whatever size you scaled it to while the type inside can come out cramped or oversized depending on how the rounding falls.

Non-integer results get rounded to the nearest whole pixel. That’s why a stroke scaled by some odd percentage occasionally looks a hair off from what the math promised.

Corner Radius Behavior During Scaling

Radius scales in direct proportion to the object’s size, same as stroke weight does. A 100px square with an 8px radius becomes a 200px square with a 16px radius. Nothing to fix by hand.

Setting rounded corners before you scale keeps the ratio predictable once the scale tool takes over.

Corner smoothing (the setting that softens a radius into that more organic, squircle-ish curve) scales along with the radius value, so a heavily smoothed corner keeps its character at any size.

How Does Scaling Interact With Constraints in a Parent Frame?

Constraints decide which edges of a child layer stay pinned when the parent frame changes size. The scale tool doesn’t override them, it works inside whatever is already set. Pin an object to the left and top, scale the parent, and the object moves relative to those two edges while the rest of the layout adjusts around it.

Nearly all the confusion here comes from one mismatch. Someone expects Scale behavior, the constraint is still a fixed pin, and the frame grows while the object inside stays exactly the size it was.

Nested frames run on the same logic, each child carrying its own constraint settings independent of the parent.

Two nested frames sitting right next to each other at identical sizes can come out completely different after you scale the outer frame, purely because their pins don’t match.

How Does Scaling Interact With Auto Layout Padding and Gaps?

Auto Layout frames recalculate padding and gap values proportionally when you scale them with K, the way stroke weight and corner radius behave on a regular shape. A 16px gap comes out around 8px if you halve the frame.

People newer to auto layout in Figma assume a manual resize does the same thing. It doesn’t. Dragging a corner handle stretches the container and leaves the spacing inside completely alone.

Those padding and gap values are what hold the white space around each element steady, so scaling is really the only method that keeps that rhythm intact at a new size.

A frame set to hug shrinks down to match its children. Fill container behaves differently, stretching to match its parent instead, and the two react in their own ways once the scale tool gets involved.

Child elements set to a fixed size sometimes resist a parent-level scale and just sit at their original dimensions while the frame changes shape around them.

Most of that friction disappears if you go in a sensible order.

• Select the outer Auto Layout frame itself, not a child sitting inside it
• Confirm every nested frame uses a consistent resizing setting before you start
• Scale from the frame level, then check the padding and gap values afterward

Should You Scale a Single Layer, a Group, or a Frame?

How much of the surrounding design needs to change decides this one. A single layer covers an isolated edit. Groups are for when several shapes have to travel together as one unit. Frames come in when the layout structure itself has to shift, not just the art sitting on top of it.

Single layer

• Fast for one-off adjustments
• Nothing nearby gets disturbed
• Not much use when several shapes need to stay aligned to each other

Group

• Keeps multiple shapes proportional to one another
• Good for compound icons and small illustrations

The cost is losing individual editability until you ungroup it again, which slows down later edits.

Frame

• Moves layout structure and content together
• Respects whatever constraints or Auto Layout rules the children already have
• Slower to reach for when all you want is a quick isolated tweak

Starting from a well-planned frame rather than a loose group avoids most of the resizing grief that turns up two weeks later, especially once constraints and Auto Layout are in the mix.

How Does Scaling Work With Components and Design System Tokens?

Scaling a component instance creates a one-off override and cuts that copy loose from whatever the main component controls. Edit the main component instead and every instance across the file updates at once.

Design systems dodge the problem entirely by storing spacing as reusable values instead of numbers typed by hand on every layer.

A few numbers worth having in your head.

• Material Design recommends 8dp increments for layout spacing, narrowing to a 4dp grid for icons and small components (Material Design guidelines)
• Figma Variables launched at Config 2023, letting number-type tokens hold spacing and corner radius values across an entire file (Figma, 2023)
• IBM’s Carbon Design System builds its spacing scale from multiples of two, four, and eight pixels (Carbon Design System)

Instance Scaling vs Editing the Main Component

Scale one instance and the override lives on that copy alone.

Edit the main component and the change lands everywhere, which is the entire reason for using components in Figma on repeated elements like buttons or cards.

A component set holds every variant of that button, and scaling one variant inside it overrides that specific size only, not the set.

The override sticks until somebody resets it. So a button scaled up on one screen won’t match its siblings anywhere else unless you clear it or resize the main component.

• Width, height, and corner radius follow whatever scale you apply to the instance
• Text set through component properties stays linked to the main component
• Swap the instance for a different variant and any manual scale override resets

Common Spacing Scale Values Across Design Systems

Material Design, Carbon, and most enterprise component libraries all run the same logic with a different starting number. Pick one small base unit, multiply it up, and every spacing decision after that follows from it.

Shopify’s Polaris does the same thing with its own base unit.

The idea traces back to the 8-point grid system, which treats spacing and sizing as multiples of one number rather than pixel counts picked on the fly.

Inside Figma these get stored as number-type Variables, so one spacing token updates every frame that references it and nobody rescales instances by hand.

How Do You Scale Multiple Layers at Once in Figma?

Select several layers, hit K, and Figma treats the whole lot as one combined bounding box. Everything inside resizes by the same ratio against that shared boundary, not against its own edges.

• Frames in the selection bring their children’s constraints along for the ride
• Vector shapes carry stroke weight and path data
• Text layers handle font size the same way they would in a single-object scale

Scale a spread-out selection from the top-left corner and the objects on the far side get pushed further apart, since everything moves relative to that one anchor point.

Holding Option (Alt on Windows) while dragging switches the origin to the center of the selection, which stops a scattered layout from drifting as it resizes.

Group the layers first if the pieces need to stay locked to each other permanently, rather than just for this one resize.

Nested instances with several layers of overrides don’t always scale cleanly through the built-in tool. Figma Community has plugins for exactly this. Reset Constraints sets every constraint in a selection to Scale in one click, which beats opening each nested layer by hand before a batch resize.

What Is the Step-by-Step Process to Scale an Object Precisely?

Precision comes from picking the input method up front, then finishing with the keyboard instead of the mouse.

1. Select the object or selection you want to resize
2. Press K to activate the scale tool
3. Type an exact percentage, dimension, or math expression into the field, or drag the bounding box for a rough pass
4. Press Enter to lock in the typed value, or use the arrow keys to nudge the result
5. Undo with Ctrl+Z (Cmd+Z on Mac) if the result overshoots what you wanted

Arrow keys move the object by 1px per press, and Shift plus an arrow key jumps it by 10px, according to Figma’s own help documentation.

That same increment logic carries into the scale field, so a rough drag can be corrected without retyping the whole value.

An undo at this stage reverses just the last scale action, not the whole editing session. Testing a value and backing out costs nothing.

How Do You Set Export Resolution After Scaling in Figma?

Canvas scale and export resolution are two separate settings, and mixing them up is one of the most common handoff mistakes between designers and developers. One changes the object’s actual size on the page. The other is a multiplier applied at export time and nowhere else.

Apple’s Human Interface Guidelines put a standard-resolution display at 1:1 pixel density, with high-resolution displays running a scale factor of 2.0 or 3.0.

Scaling an object up on the canvas does not do the export multiplier’s job.

A 100px icon scaled to 200px on the canvas still exports as a soft, low-detail image at 1x unless the export scale gets raised to match the target screen’s pixel density.

It usually surfaces when someone resizes a frame for a mockup, misses that the export panel still reads 1x, and hands off a blurry asset that comes back for a re-export the next morning.

Single assets work the same way through the image export panel, where the scale multiplier sits right next to the format dropdown.

Which multiplier a given screen actually needs comes down to pixel density.

When Does the Scale Tool Not Work as Expected in Figma?

The tool has real limits, and knowing them ahead of time saves a lot of guessing later.

• Locked layers stay exactly where they are until you unlock them, and a couple of selection types are intentionally non-scalable
• Boolean groups built with union, subtract, or intersect can distort unevenly when the individual paths inside were drawn at different proportions
• Figma’s own support team advises against Scale on instances with several layers of nesting, pointing to manual size overrides as the more reliable route
• A fixed-width text box holds its frame at the new size, while auto-resize text reflows and can land on a different point size than a quick scale suggested
• Scale an object down far enough and the corner radius exceeds what the shortest edge can physically hold, flattening the curve into a straight line
• Shadows or blurs pinned to an absolute pixel amount in code or a plugin won’t always track the new proportions the way a native Figma effect does

Boolean groups are the worst of these. Cutting a shape with a subtract operation bakes the original proportions into the result, and scaling afterward can’t fully undo that.

None of this makes the tool unreliable.

A locked layer, a deeply nested instance, or a boolean shape just needs a quick look before you trust the scale value at face value.

FAQ on How To Scale In Figma

Is There a Difference Between Scaling and Resizing in Figma?

Resizing changes only width and height, leaving stroke weight and corner radius untouched.

Scaling through the K tool adjusts every linked property together, since Figma treats the two as separate operations rather than two names for the same drag.

Does Scaling Reduce Image Quality in Figma?

Vector shapes and text keep full clarity at any size, since paths and font outlines redraw at the new dimensions.

Raster images don’t gain new pixel data, so scaling one up past its original size makes it look soft or blurry.

Are There Plugins Worth Using for Batch Scaling in Figma?

Figma Community carries dedicated plugins beyond the built-in tool.

Auto Resize Frame syncs frame height to its contents automatically, and HyperCrop batch-resizes exported images against social and device presets, useful when a project needs dozens of sizes at once.

Can You Undo a Scale Action in Figma?

Ctrl+Z (Cmd+Z on Mac) reverses one scale step at a time, so pressing it repeatedly steps back through several prior resizes in order.

Redo brings a reversed scale back with Ctrl+Shift+Z, keeping the whole adjustment reversible mid-workflow.

Does Scaling Affect Exported PDF or SVG Differently Than PNG?

PDF and SVG exports stay vector-based, so a scaled object holds crisp edges at any output size without needing a 2x or 3x multiplier.

PNG exports are raster, so the multiplier chosen at export time still decides the final pixel count.

What Does Scaling in Figma Cost to Maintain?

Maintenance drops to almost nothing when every scale ratio traces back to a stored Variable, instead of a number somebody typed into one component instance during a rushed Friday resize.

A Variable costs one short setup step now and zero repeated fixes later. The catch is that the value stays locked to whatever base unit the team already agreed on, so it’s only as good as that call.

• Fix the frame’s constraints first
• Convert loose shapes into a proper component second
• Let a Variable carry the spacing value third

That order holds because a constraint set wrong at the frame level breaks everything scaled inside it, while a spacing value fixed last only affects one property.

Turning that single spacing Variable into something documented and reusable is the next step, and building a design system in Figma is where that consistency actually gets locked down.