The Box Model

Know that padding⁠—and many other properties, including border and margin⁠—can be specified with a shorthand property to make it easier to use the same spacing all around, or shared top/​bottom and left/​right.

Shorthand Properties – MDN
Be wary of the siren call of shorthand properties!

						section { padding: 1rem; }
section { padding: 1rem 2rem; }
section { padding: 1rem 2rem 4rem; }
section { padding: 1rem 2rem 4rem 2rem; }

			
	

						section {
	padding-top: 1rem;
	padding-bottom: 4rem;
	padding-right: 2rem;
	padding-left: 2rem;
}

			
	

By default, every element is static⁠—just meaning its normal, stacked position in the document.

You’ll rarely, if ever, actually set this yourself⁠—it’s the default!

The first thing we might want to do is adjust an element from that normal static position, which we can do with relative positioning.

Once you have set position: relative; you can use the logical inset-block-start, inset-inline-end, inset-block-end, and inset-inline-start values (with any of the units, above) to move the element away from its default, normal position in the flow:

absolute positioning is somewhat similar to relative⁠—but instead of placing an element in relation to its own default position, it uses the position of its nearest positioned ancestor as the origin.

So absolute elements will go “up the tree” of parents and wrapper elements until they find one set to anything other than default/​static⁠—then the same offset properties the element around from there.

Importantly, position: absolute; also removes the element from the normal document flow⁠—meaning it takes up no space in the page layout.

This is often used for exacting, specific design element placement. But it is inherently brittle⁠!

fixed positioning also removes the element from the document flow, but it places elements with relation to the browser viewport⁠—the boundaries of the window or device.

So position: fixed; brings the element completely out of the page’s normal flow, like it is sitting on its own separate layer.

This is often used for things like navigation elements.

The most recent addition to the position party, position: sticky; elements are placed according to the normal flow of the document, like static, until their nearest scrolling ancestor (usually the viewport) moves past them. The element is then stuck in relation to this element.

This is often used for headers on tables and lists.

Okay, z-index is not strictly positioning⁠—it is a separate property. You can see that all these position properties have given us ways to make things overlap, and z-index is how we can decide the front-to-back ordering (think z-axis).

Z-Index – MDN
This can be tricky to work with!

By default, items that are lower in the HTML (coming after each other) are in front of higher, earlier elements:

A whole lot of things make a new stacking context (including most position changes) which is kind of like a group (or a Figma frame) that has its own internal depth/​overlap order.

No amount of internal z-index adjustments can “break” something out of that group⁠—which is one of the reasons why z can be really difficult to understand and tricky to use. But you can always adjust the z-index of the group, as we do here!

As we discussed, most HTML elements are block-level by default. But you can also set display: block; manually on an inline element, too. This would mean that it starts on a new line, takes up the full width available, and you can specify a block-size, inline-size, and use margin above and below:

And then going the other way, you can make block elements switch to inline with display: inline;. They will no longer start on their own lines, will only take up as much space as their content/​children, and don’t accept block-size or inline-size (or any -block-start/​-block-end) properties:

You can also combine the qualities of block and inline with display: inline-block;. These elements take block-size and inline-size (and vertical margin) like block-level elements, but do not start on their own line:

Setting display: none; hides an element visually (and from screen readers) in the document⁠—as well as taking it out of the flow. (Keep in mind the HTML is still there, if someone opens up the source code.)

This is a common way to hide/​show (by setting another display property) elements on the page, but it will reflow the document when applied⁠—as if the element is actually added/​removed from the HTML:

You can also hide something visually without taking it out of the document flow, which is useful when you don’t want the page to jump/​reflow when something appears/​disappears.

Visibility – MDN
This also hides elements from assistive technologies (screen readers).

Setting visibility: hidden; keeps the space an element had before, but makes it invisible and unable to be interacted with. The value visible is the default:

Another way to hide an element visually is to adjust opacity, which uses values on a scale from 0⁠–⁠1 or 0%⁠–⁠100%. This differs from visibility because elements with no (or partial) opacity can still be interacted with:

Opacity – MDN
The entire element and its descendents are adjusted, as one.

Keep in mind that display: none;, visibility: hidden;, and opacity: 0; only hide things in the rendered browser view. The HTML is always still visible in the source code!

The declarations float: inline-start; and float: inline-end; take an element out of the normal flow and place it on the left or right side of its parent container.

Any text siblings will then flow around the element⁠—like a text wrap⁠—filling up any available space to its side. They will go as far up as the top of the floated element:

Since this takes the floated element out of the flow, if we want the following element (often another text block, like a <p>) to not move up it needs to be cleared with clear: inline-start; , clear: inline-end;, or clear: both;.

Applied on the following element, it will make it stay entirely below (clear of) the floated element:

If you have a parent wrapper and no following element, there won’t be anything there to clear the float⁠—meaning the parent will collapse down to the size of the text content. Almost never what you want.

You can solve this broken look with a clearfix hack, which uses a pseudo-element as an ersatz last-child to clear the container.

Generally, folks try and avoid floats⁠—they aren’t common in modern design patterns and have been giving people headaches for… decades now.

They require you to know how long your content is and also how big your viewport/​page will be⁠—both things that you don’t always have control over in responsive/​mobile 2025. But sometimes they are still the only thing that can do what you need!

We’ll cover these next unit! They’ll make your (layout) life easier.

E.g.: ____________   H1 has a 1 character margin   So does H2   P starts here and could go on forever. Wow, a 5 character left margin sure looks great! _____ | + + | Wow, you can do | @ | images as well? | --- | Then you'll |_____| want a 1 character margin on the left side. Until, you're below the image that is.   This is where we [find] the simple stacked box model is a bit too simple.

Håkon Wium Lie, 1995