HTML a CSS tvoří základ téměř každého webového rozhraní, které vytvářím.

HTML používám k definování struktury a významu, zatímco CSS řídí rozvržení, prezentaci, responzivitu a vizuální systém.

I když pracuji s WordPressem, Bricks Builderem, JavaScript frameworky nebo rozhraními ve stylu aplikací, HTML a CSS zůstávají pod vším ostatním.

Pro mě nejde o „základní frontendové technologie“.

Jsou vrstvou, která rozhoduje o tom, zda je web strukturálně správný, přístupný, responzivní, udržovatelný a rychlý.

Jak používám HTML a CSS

HTML a CSS používám například pro:

Než přidám zbytečný framework nebo JavaScript, dávám přednost nativním možnostem webové platformy.

Sémantické HTML

Sémantické HTML používám všude tam, kde obsah má smysluplnou strukturu.

Patří sem například prvky:

Cílem není pouze to, aby stránka vizuálně vypadala správně.

Dokument musí dávat smysl také svou strukturou.

Sémantický markup zlepšuje:

Struktura dokumentu

Stránka by měla mít jasnou hierarchii.

Věnuji pozornost:

Vyhýbám se libovolným kontejnerům tam, kde existuje významově vhodnější HTML prvek.

Vizuální a dokumentová hierarchie by se měly navzájem podporovat.

Nadpisy

Nadpisy jsou strukturální prvky, ne zkratka pro stylování.

Používám je k vyjádření hierarchie dokumentu.

Například:

H1
→ téma stránky

H2
→ hlavní sekce

H3
→ podsekce

Úroveň nadpisu nevybírám jen proto, že má zrovna požadovanou velikost písma.

Typografie patří do CSS.

Význam dokumentu patří do HTML.

Tlačítka a odkazy

Rozlišuji mezi navigací a akcemi.

Odkaz slouží k přesunu někam jinam.

Tlačítko slouží k provedení akce.

Vyhýbám se klikacím prvkům typu div tam, kde už existuje nativní interaktivní prvek.

Správné HTML prvky automaticky poskytují užitečné chování, například:

Tím se snižuje množství vlastní práce potřebné pro zajištění přístupnosti.

Formuláře

Formuláře patří mezi oblasti, kde na správném HTML záleží nejvíce.

Používám:

Vizuální placeholder nenahrazuje skutečný label.

Formuláře navrhuji tak, aby zůstaly srozumitelné i pro uživatele ovládající web klávesnicí nebo asistivními technologiemi.

Typy vstupních polí

Kde je to možné, používám nejvhodnější nativní typ vstupu.

Příklady:

email
url
number
date
tel

Správné typy vstupních polí mohou zlepšit validaci i chování mobilní klávesnice.

Nativní funkcionalita prohlížeče bývá často spolehlivější než ruční vytváření základního chování vstupních polí.

Přístupnost

Přístupnost začíná už u struktury markupu a layoutu.

Zohledňuji:

Preferuji řešit přístupnost strukturálně místo přidávání velkého množství ARIA atributů jako kompenzace za nesprávně použité HTML.

Nativní sémantiku používám všude tam, kde je to možné.

ARIA

ARIA je užitečná tam, kde nativní HTML nedokáže plně vyjádřit požadované chování.

Používám ji opatrně.

ARIA by měla sémantiku doplňovat, ne zbytečně nahrazovat správné HTML.

U složitějších vlastních ovládacích prvků zohledňuji:

Pokud už nativní HTML prvek poskytuje potřebnou sémantiku, zpravidla mu dávám přednost.

CSS

CSS používám jako jazyk pro layout a design systém, ne jako soubor izolovaných vizuálních oprav.

Udržovatelný stylesheet by měl vyjadřovat konzistentní pravidla pro:

Preferuji znovupoužitelné systémy před jednorázovými deklaracemi opakovanými napříč jednotlivými stránkami.

Moderní CSS

Moderní CSS dokáže vyřešit mnoho problémů, které dříve vyžadovaly značné množství JavaScriptu nebo externí frameworky.

Používám například:

Preferuji nativní layout engine prohlížeče před přidáváním složitosti v situacích, které CSS řeší samo.

Flexbox

Flexbox používám pro layouty, kde se prvky potřebují primárně zarovnávat podél jedné osy.

Typické příklady zahrnují:

Je obzvlášť užitečný tam, kde mají prvky dynamické rozměry.

Vyhýbám se ručním marginům a positioningu tam, kde Flexbox dokáže zamýšlený vztah vyjádřit přímo.

CSS Grid

CSS Grid používám pro layouty s výraznější dvourozměrnou strukturou.

Příklady zahrnují:

Grid umožňuje strukturu vyjádřit explicitně místo jejího simulování pomocí vnořených kontejnerů.

Typický responzivní grid se může automaticky přizpůsobovat dostupné šířce.

Grid a Flexbox dohromady

Grid a Flexbox nevnímám jako konkurenční technologie.

Řeší rozdílné problémy.

Stránka může používat Grid pro celkovou strukturu a Flexbox uvnitř jednotlivých komponent.

Volba správného layout modelu obvykle vede k jednoduššímu CSS.

Responzivní design

Layouty navrhuji podle dostupného prostoru, ne podle jednoho pevného rozměru zařízení.

Zohledňuji:

Cílem není pouze přidat několik breakpointů.

Rozhraní musí zůstat použitelné i při změně prostředí.

Mobile-first design

Kde je to praktické, začínám základním layoutem a postupně ho rozšiřuji pro větší obrazovky.

To může vést k jednoduššímu CSS a pomáhá zajistit, že mobilní verze není pouze dodatečná úprava.

Konkrétní přístup ale vždy volím podle projektu.

Důležité je, aby mobilní chování bylo navržené záměrně a neřešilo se až na konci.

Fluidní layouty

Kde je to vhodné, preferuji flexibilní rozměry.

Místo spoléhání pouze na pevné pixely používám kombinace:

Díky tomu se layout může přizpůsobovat plynule, ne jen skokově na několika libovolných breakpointech.

Fluidní typografie

Moderní CSS umožňuje škálovat typografii mezi rozumnou minimální a maximální velikostí.

Například:

font-size: clamp(1.8rem, 4vw, 3.5rem);

Výsledkem může být přirozenější škálování napříč různými velikostmi viewportu.

Zároveň stále hlídám, aby výsledek zůstal čitelný a předvídatelný.

Šířky kontejnerů

Čitelný obsah by se neměl jednoduše roztáhnout přes celý velký monitor.

Používám vhodné maximální šířky pro:

Různé typy obsahu mohou vyžadovat různé limity šířky.

Například dlouhý text těží z více kontrolované délky řádku než datový dashboard.

CSS Custom Properties

CSS custom properties používám k vytváření sdílených designových hodnot.

Například:

:root {
    --space-sm: 0.75rem;
    --space-md: 1.5rem;
    --space-lg: 3rem;
    --radius-card: 1rem;
}

Tyto proměnné mohou reprezentovat:

Díky tomu lze design systém měnit globálně mnohem jednodušeji.

Design tokeny

U větších projektů přemýšlím spíše v design tokenech než v izolovaných hodnotách stylů.

Token reprezentuje konkrétní designové rozhodnutí.

Například:

primární barva textu
barva povrchu
malý rozestup
velký rozestup
zaoblení karty
stupnice nadpisů

Komponenty pak tyto společné hodnoty využívají.

Výsledkem je mnohem konzistentnější rozhraní.

Typografie

Typografie je jedním z hlavních strukturálních nástrojů rozhraní.

Zohledňuji:

Vyhýbám se definování typografie samostatně pro každý jednotlivý prvek.

Konzistentní typografická škála usnadňuje údržbu designu i CSS.

Výška řádku

Čitelný text potřebuje vhodné řádkování.

U běžného textu se vyhýbám příliš těsné výšce řádku.

Velké nadpisy naopak mohou těžit z kompaktnějšího řádkování.

Typografie by měla odpovídat typu obsahu, ne jedné univerzální hodnotě.

Barevné systémy

Definuji sémantické barvy místo nahodilých hodnot roztroušených po stylesheetu.

Například:

text-primary
text-muted
surface
surface-raised
accent
error

Díky tomu lze rozhraní v budoucnu snadněji měnit a přizpůsobovat tématům.

Význam barvy je užitečnější než její hexadecimální hodnota.

Tmavý režim

Kde je to vhodné, navrhuji barevné systémy tak, aby podporovaly světlé i tmavé téma.

Sémantické proměnné tento proces výrazně usnadňují.

Komponenty by neměly být závislé na předpokladech typu:

pozadí je vždy bílé
text je vždy černý

Měly by používat hodnoty definované na úrovni tématu.

CSS architektura

S růstem projektu začíná být organizace stylesheetů důležitá.

Preferuji jasné oddělení mezi:

Vyhýbám se tomu, aby se stylesheet postupně změnil v nahromadění stále specifičtějších override pravidel.

Dobrá CSS architektura snižuje potřebu používat !important a eskalovat specificitu selektorů.

Specificita

Specificita CSS by měla být předvídatelná.

Preferuji znovupoužitelné třídy před hluboce vnořenými selektory, například:

.page .section .card .content span

Příliš specifické selektory komplikují budoucí změny.

Komponenta by měla být zpravidla stylovatelná pomocí jasného a relativně mělkého selektoru.

Vyhýbání se !important

!important používám pouze tam, kde pro to existuje jasný důvod.

Časté spoléhání na něj obvykle signalizuje problém se specificitou nebo architekturou.

Může komplikovat budoucí override pravidla a skrývat skutečnou strukturu stylesheetu.

Stylování komponent

Styly stavím kolem znovupoužitelných komponent.

Například:

.card
.card__title
.card__content
.card--featured

Konkrétní strategie pojmenování se může mezi projekty lišit.

Důležitý je princip jasně definované hranice komponenty a předvídatelných variant.

Utility třídy

Malé utility třídy mohou být užitečné pro běžné layoutové chování.

Příklady mohou zahrnovat:

Utility vrstvu udržuji pod kontrolou.

Pokud se každá vizuální vlastnost stane samostatnou utility třídou bez konzistentního systému, HTML může být obtížně čitelné.

CSS nesting

Tam, kde je podporovaný a vhodný, může moderní CSS nesting zpřehlednit organizaci souvisejících selektorů.

I tak se vyhýbám hlubokému vnořování.

Nesting by měl zlepšovat čitelnost, ne znovu vytvářet problémy vysoce specifických řetězců selektorů.

Logické vlastnosti

Logické CSS vlastnosti umožňují lépe přizpůsobit layout směru zápisu.

Místo uvažování pouze v pojmech fyzického „vlevo“ a „vpravo“ může moderní CSS pracovat s:

To je užitečné u rozhraní, která mohou potřebovat širší podporu lokalizace.

Internacionalizace

Různé jazyky mohou layout výrazně ovlivnit.

Přeložený text může být:

Vyhýbám se návrhu komponent, které fungují pouze s jednou přesně dlouhou anglickou textovou hodnotou.

Layout by měl zvládat realistické rozdíly v obsahu.

Obrázky

HTML markup obrázků ovlivňuje použitelnost i výkon.

Zohledňuji:

Prohlížeč by měl mít dostatek informací k rezervování prostoru v layoutu a výběru vhodného zdroje.

Responzivní obrázky

Různá zařízení nepotřebují vždy stejnou velikost obrázku.

Kde je to vhodné, používám mechanismy responzivních obrázků, aby si prohlížeč mohl vybrat odpovídající asset.

To může snížit zbytečný objem přenesených dat, zejména na mobilních zařízeních.

Aspect ratio

Kde to dává smysl, používám CSS vlastnost aspect-ratio k rezervování předvídatelného prostoru pro média.

To může omezit layout shifts během načítání.

Zároveň to usnadňuje správu responzivních kontejnerů pro obrázky a video.

Výkon

HTML a CSS přímo ovlivňují výkon frontendu.

Věnuji pozornost:

Přidávání dalšího markupu není bez nákladů.

Hluboce vnořený DOM může prodražit stylování i samotné vykreslování v prohlížeči.

Složitost DOMu

Page buildery usnadňují vytváření zbytečných wrapperů.

Snažím se proto držet markup tak mělký, jak to layout dovoluje.

Místo:

container
→ container
→ container
→ container
→ content

preferuji pouze takovou strukturu, která má skutečný účel.

Čistší markup se snáze kontroluje, styluje a udržuje.

Stabilita layoutu

Stránky by se během načítání neměly výrazně posouvat.

Layout shifts omezuji definováním předvídatelných rozměrů pro obsah, jako jsou:

Stabilní stránka působí výrazně profesionálněji než stránka, na které se během načítání neustále přesouvají tlačítka a text.

Webové fonty

Fonty mohou mít výrazný vliv na načítání stránky.

Zohledňuji:

Design se automaticky nestává lepším jen proto, že stahuje mnoho souborů s fonty.

Výkon a vizuální kvalita musí být v rovnováze.

Nativní CSS před JavaScriptem

Mnoho typů chování rozhraní lze dnes realizovat přímo pomocí CSS.

Kde je to vhodné, preferuji CSS pro:

JavaScript přidávám až tam, kde ho skutečně vyžaduje aplikační logika nebo interakce.

Omezení zbytečného JavaScriptu zpravidla vede k robustnějším rozhraním.

Přechody

CSS transitions používám pro jemnou zpětnou vazbu při interakci.

Příklady zahrnují:

Přechody by měly podporovat interakci.

Vyhýbám se animování každé vlastnosti nebo zbytečnému zpomalování rozhraní.

Preference omezeného pohybu

Někteří uživatelé preferují omezené množství pohybu.

Pokud rozhraní používá výraznější animace, zohledňuji uživatelskou preferenci reduced motion.

Rozhraní musí zůstat srozumitelné i bez závislosti na animacích.

Hover stavy

Hover je užitečný na zařízeních s ukazatelem, ale neměl by být nutný pro základní funkcionalitu.

Dotyková zařízení neposkytují stejný model interakce.

Komponenty navrhuji tak, aby důležité akce zůstaly dostupné i bez hoveru.

Focus stavy

Uživatelé ovládající web klávesnicí potřebují viditelnou indikaci focusu.

Vyhýbám se globálnímu odstraňování focus outline bez dostupné náhrady.

Focus stav by měl být jasně viditelný a zároveň konzistentní s vizuálním systémem.

Pseudotřídy

Moderní pseudotřídy poskytují velmi silné možnosti stylování.

Používám je například pro stavy:

Vizuální stav tak může zůstat přímo propojený se sémantickým stavem prohlížeče.

Nativní stavy formulářů

Ovládací prvky formulářů v prohlížeči už samy zpřístupňují užitečné stavy.

Pomocí CSS komunikuji například:

Preferuji rozšiřování nativního chování před zbytečným nahrazováním každého formulářového prvku vlastní implementací.

CSS Grid pro aplikační rozhraní

Grid je obzvlášť užitečný pro aplikační layouty obsahující:

Tyto layouty se mohou přizpůsobit z vícesloupcové desktopové struktury na jednodušší mobilní zobrazení bez výrazných změn podkladového HTML.

Sticky positioning

Sticky positioning používám tam, kde skutečně zlepšuje použitelnost.

Příkladem může být:

Vyhýbám se příliš velkému množství sticky prvků, zejména na malých obrazovkách, kde mohou zabírat cennou část viewportu.

Overflow

Scrollovatelný obsah vyžaduje promyšlenou práci s overflow.

Věnuji pozornost například:

Neočekávané přetékání prvku mimo viewport je častým zdrojem problémů v mobilních layoutech.

Tabulky

Pro skutečná tabulková data používám HTML tabulky.

Nenahrazuji sémantické tabulky libovolnými grid layouty jen kvůli dosažení určitého vzhledu.

Pro úzké obrazovky navrhuji vhodnou responzivní strategii místo narušení vztahu mezi hlavičkami a daty.

Content-first layout

Preferuji, aby rozhodnutí o layoutu vycházela ze skutečného obsahu.

Design, který funguje pouze s dokonale zvoleným placeholder textem, často selže po vložení reálného obsahu.

Rozhraní testuji s:

Robustní layout by měl zvládat všechny tyto situace.

WordPress

HTML a CSS zůstávají zásadní i při práci s WordPressem.

Šablony a buildery nakonec vždy vytvářejí HTML, které vykresluje prohlížeč.

Porozumění tomuto generovanému výstupu mi umožňuje:

WordPress nevnímám jako černou skříňku.

Bricks Builder

Bricks Builder používám jako vizuální vývojovou vrstvu, přitom ale stále pracuji přímo s principy HTML a CSS.

Používám:

Vizuální editor urychluje vývoj, ale konečný výsledek stále určují podkladové technologie prohlížeče.

Advanced Custom Fields

ACF řídí strukturovaný obsah.

HTML a CSS určují způsob jeho prezentace.

Dynamické pole může obsahovat například:

Šablona stále potřebuje správný markup a layout pro prezentaci těchto dat.

WooCommerce

Rozhraní WooCommerce vyžadují pečlivou práci s HTML a CSS, protože e-commerce workflow musí zůstat použitelné a přístupné.

Věnuji pozornost:

Vizuální úpravy by neměly zhoršit použitelnost transakčního procesu.

JavaScript

HTML, CSS a JavaScript mají rozdílné odpovědnosti.

Obecně o nich přemýšlím takto:

HTML
→ struktura a význam

CSS
→ prezentace a layout

JavaScript
→ chování a aplikační logika

V reálných projektech se tyto oblasti přirozeně částečně překrývají, ale jejich koncepční oddělení vede k čistším rozhraním.

Browser API

Při tvorbě aplikací běžících v prohlížeči poskytují HTML a CSS rozhraní kolem funkcionality založené na API, jako jsou:

I technicky složité aplikace stále potřebují přehledný a dobře použitelný frontend.

Progressive enhancement

Kde je to vhodné, navrhuji rozhraní tak, aby jejich základní struktura zůstala použitelná ještě před přidáním pokročilé JavaScript funkcionality.

To může zlepšit:

Ne každá aplikace může plně fungovat bez JavaScriptu, její HTML by ale stále mělo smysluplně reprezentovat rozhraní.

SEO

Struktura HTML přímo ovlivňuje schopnost vyhledávačů porozumět obsahu.

Věnuji pozornost:

Vyhýbám se používání vizuální prezentace jako náhrady za strukturální význam.

Vyhledávače zpracovávají strukturu dokumentu, ne designový soubor.

Crawlability

Důležitý obsah by měl být reprezentovaný způsobem, kterému lze spolehlivě porozumět.

U obsahově rozsáhlých webů se bez reálného technického důvodu vyhýbám architekturám, které skrývají zásadní obsah za křehké chování čistě na straně klienta.

Implementace by měla podporovat jak uživatele, tak automatizované systémy, které web zpracovávají.

Udržovatelnost

Nejlepší HTML a CSS nejsou ta nejsložitější.

Preferuji implementace, ve kterých může další vývojář snadno pochopit:

Design systém by měl budoucí změny usnadnit, ne nutit vývojáře hledat mezi stovkami izolovaných override pravidel.

Kompatibilita prohlížečů

Moderní prohlížeče podporují stále schopnější webovou platformu.

Moderní CSS funkce používám tam, kde jsou vhodné pro cílové publikum.

U novější funkcionality zohledňuji:

Vyhýbám se zbytečným kompatibilitním hackům pro zastaralá prostředí, pokud je projekt výslovně nevyžaduje.

Ladění

Vývojářské nástroje prohlížeče jsou zásadní součástí mého workflow s HTML a CSS.

Používám je ke kontrole:

Preferuji nalezení skutečné příčiny problému s layoutem před přidáváním náhodných override pravidel, dokud problém nezmizí.

Vyhýbání se CSS záplatám

Stylesheet se může postupně změnit v řetězec záplat:

původní pravidlo
→ override
→ mobilní override
→ pozdější override
→ !important

Tomuto vzoru se snažím vyhýbat.

Pokud je problém v samotné komponentě, preferuji opravit její strukturu nebo původní pravidlo místo nekonečného přidávání výjimek.

HTML & CSS v mém technologickém stacku

HTML a CSS běžně používám společně s technologiemi, jako jsou:

Tvoří strukturální a vizuální základ pod těmito technologiemi vyšší úrovně.

Proč používám HTML & CSS přímo

Frameworky, CMS platformy a vizuální vývojové nástroje používám tam, kde zvyšují produktivitu.

Pod nimi se ale stále spoléhám na znalost HTML a CSS.

Je to důležité, protože každé webové rozhraní se nakonec skládá z:

HTML
+
CSS
+
chování prohlížeče

Porozumění této vrstvě mi dává kontrolu nad sémantikou, přístupností, výkonem, responzivitou a udržovatelností.

Zároveň díky tomu nejsem závislý na builderu nebo frameworku při řešení každého frontendového problému.

HTML poskytuje strukturu.

CSS poskytuje vizuální systém.

Všechno ostatní na těchto základech staví.

Proto HTML a CSS považuji za základní inženýrské nástroje mého webového technologického stacku, nikoli za úvodní technologie, které s příchodem nástrojů vyšší úrovně přestávají být relevantní.

HTML and CSS are the foundation of nearly every web interface I build.

I use HTML to define structure and meaning, and CSS to control layout, presentation, responsiveness and visual systems.

Even when I work with WordPress, Bricks Builder, JavaScript frameworks or application-style interfaces, HTML and CSS remain underneath everything.

For me, they are not “basic frontend technologies”.

They are the layer that determines whether a website is structurally correct, accessible, responsive, maintainable and fast.

How I use HTML and CSS

I use HTML and CSS for tasks such as:

I prefer using native web-platform capabilities before adding unnecessary frameworks or JavaScript.

Semantic HTML

I use semantic HTML whenever the content has a meaningful structure.

That includes elements such as:

The goal is not merely to make the page look correct.

The document should also make sense structurally.

Semantic markup improves:

Document Structure

A page should have a clear hierarchy.

I pay attention to:

I avoid using arbitrary containers when a more meaningful HTML element exists.

The visual hierarchy and document hierarchy should support each other.

Headings

Headings are structural elements, not styling shortcuts.

I use them to represent the hierarchy of the document.

For example:

H1
→ Page topic

H2
→ Major section

H3
→ Subsection

I avoid selecting heading levels purely because one happens to have a desirable font size.

Typography belongs in CSS.

Document meaning belongs in HTML.

Buttons and Links

I distinguish between navigation and actions.

A link is for moving somewhere.

A button is for doing something.

I avoid using clickable div elements where a native interactive element already exists.

Correct elements provide useful behavior automatically, including:

This reduces the amount of custom accessibility work required.

Forms

Forms are one of the areas where correct HTML matters most.

I use:

A visual placeholder is not a replacement for a real label.

I design forms so they remain understandable for keyboard and assistive-technology users.

Input Types

I use the most appropriate native input type where possible.

Examples include:

email
url
number
date
tel

Correct input types can improve validation and mobile keyboard behavior.

Native browser functionality is often more reliable than recreating basic input behavior manually.

Accessibility

Accessibility begins with markup and layout architecture.

I consider:

I prefer solving accessibility structurally rather than adding large amounts of ARIA to compensate for incorrect HTML.

Native semantics should be used wherever possible.

ARIA

ARIA is useful when native HTML cannot fully express the required behavior.

I use it carefully.

ARIA should enhance semantics, not replace correct HTML unnecessarily.

For complex custom controls, I consider:

If a native HTML element already provides the required semantics, I usually prefer the native element.

CSS

I use CSS as a layout and design-system language rather than a collection of isolated visual overrides.

A maintainable stylesheet should express consistent rules for:

I prefer reusable systems over one-off declarations repeated across individual pages.

Modern CSS

Modern CSS can solve many problems that previously required substantial JavaScript or external frameworks.

I use features such as:

I prefer using the browser’s native layout engine instead of adding complexity where CSS already provides the solution.

Flexbox

I use Flexbox for layouts where elements primarily need to align along one axis.

Typical use cases include:

It is particularly useful when content dimensions are dynamic.

I avoid using manual margins and positioning when Flexbox can describe the intended relationship directly.

CSS Grid

I use CSS Grid for layouts with stronger two-dimensional structure.

Examples include:

Grid allows the structure to be expressed explicitly rather than simulated with nested containers.

A typical responsive grid can adapt automatically as available width changes.

Grid and Flexbox Together

I do not treat Grid and Flexbox as competing technologies.

They solve different problems.

A page may use Grid for its overall structure and Flexbox inside individual components.

Choosing the correct layout model usually results in simpler CSS.

Responsive Design

I build layouts that respond to available space rather than one fixed device size.

I consider:

The goal is not simply to add a few breakpoints.

The interface should remain usable as its environment changes.

Mobile-First Design

Where practical, I begin with the essential layout and progressively enhance it for larger screens.

This can produce simpler CSS and helps ensure the mobile experience remains intentional.

I still choose the approach according to the actual project.

The important part is that mobile behavior is designed, not treated as an afterthought.

Fluid Layouts

I prefer flexible sizing where appropriate.

Instead of relying entirely on fixed pixel widths, I use combinations of:

This allows layouts to adapt smoothly rather than changing only at a handful of arbitrary breakpoints.

Fluid Typography

Modern CSS can scale typography between sensible minimum and maximum sizes.

For example:

font-size: clamp(1.8rem, 4vw, 3.5rem);

This can produce more natural scaling across different viewport sizes.

I still make sure the result remains readable and predictable.

Container Widths

Readable content should not simply stretch across an entire large monitor.

I use appropriate maximum widths for:

Different types of content can require different width constraints.

Long-form text, for example, benefits from more controlled line length than a data dashboard.

CSS Custom Properties

I use CSS custom properties to create shared design values.

For example:

:root {
    --space-sm: 0.75rem;
    --space-md: 1.5rem;
    --space-lg: 3rem;
    --radius-card: 1rem;
}

These variables can represent:

This makes a design system easier to change globally.

Design Tokens

For larger projects, I think in terms of design tokens rather than isolated style values.

A token represents a deliberate design decision.

Examples include:

primary text color
surface color
small spacing
large spacing
card radius
heading scale

Components then consume these shared decisions.

This produces a much more coherent interface.

Typography

Typography is one of the main structural tools in an interface.

I consider:

I avoid defining typography independently for every individual element.

A consistent type scale makes both the design and the CSS easier to maintain.

Line Height

Readable text needs appropriate line spacing.

I avoid excessively tight line heights for body content.

At the same time, large headings may benefit from tighter spacing.

Typography should reflect the type of content rather than one universal value.

Color Systems

I define semantic colors rather than using arbitrary values throughout the stylesheet.

For example:

text-primary
text-muted
surface
surface-raised
accent
error

This makes the interface easier to theme and change later.

The meaning of a color is more useful than its hexadecimal value.

Dark Mode

Where appropriate, I design color systems that can support both light and dark themes.

Using semantic variables makes this much easier.

Components should not depend on assumptions such as:

background is always white
text is always black

They should consume theme-level values.

CSS Architecture

As a project grows, stylesheet organization becomes important.

I prefer clear separation between:

I avoid allowing the stylesheet to become an accumulation of increasingly specific overrides.

Good CSS architecture reduces the need for !important and selector escalation.

Specificity

CSS specificity should remain predictable.

I prefer reusable classes over deeply nested selectors such as:

.page .section .card .content span

Overly specific selectors make later changes difficult.

A component should usually be styleable through a clear and relatively shallow selector.

Avoiding !important

I use !important only where there is a clear reason.

Frequent reliance on it usually indicates a specificity or architecture problem.

It can make future overrides harder and hide the actual structure of the stylesheet.

Component Styling

I build styles around reusable components.

For example:

.card
.card__title
.card__content
.card--featured

The exact naming strategy can differ between projects.

The important principle is that the component has a clear boundary and predictable variants.

Utility Classes

Small utility classes can be useful for common layout behavior.

Examples may include:

I keep the utility layer controlled.

If every visual property becomes its own utility without a coherent system, the HTML can become difficult to read.

CSS Nesting

Where supported and appropriate, modern CSS nesting can make related selectors easier to organize.

I still avoid deeply nested structures.

Nesting should improve readability, not recreate the problems of highly specific selector chains.

Logical Properties

Logical CSS properties can make layouts more adaptable to writing direction.

Instead of thinking only in terms of physical left and right, modern CSS can express:

This is useful when interfaces may need broader localization support.

Internationalization

Different languages can significantly affect layout.

Translated text may be:

I avoid designing components that only work for one exact English label length.

Layouts should tolerate realistic content variation.

Images

HTML image markup affects both usability and performance.

I consider:

The browser should know enough about an image to reserve layout space and select an appropriate resource.

Responsive Images

Different devices do not always need the same image resolution.

I use responsive image mechanisms where appropriate so the browser can select a suitable asset.

This can reduce unnecessary transfer size, particularly on mobile devices.

Aspect Ratio

I use CSS aspect-ratio where useful to reserve predictable media space.

This can help reduce layout shifts while content is loading.

It also makes responsive image and video containers easier to manage.

Performance

HTML and CSS directly affect frontend performance.

I pay attention to:

Adding more markup is not free.

A deeply nested DOM can make both styling and browser rendering more expensive.

DOM Complexity

Page builders can make it easy to create unnecessary wrappers.

I try to keep markup as shallow as the layout allows.

Instead of:

container
→ container
→ container
→ container
→ content

I prefer using only the structure that has an actual purpose.

Cleaner markup is easier to inspect, style and maintain.

Layout Stability

Pages should not move dramatically while loading.

I reduce layout shifts by defining predictable dimensions for content such as:

A stable page feels significantly more polished than one where buttons and text continually move during loading.

Web Fonts

Fonts can have a substantial impact on page loading.

I consider:

A design does not automatically become better because it downloads many font files.

Performance and visual quality need to be balanced.

Native CSS Before JavaScript

Many interface behaviors can now be implemented with CSS.

Where appropriate, I prefer CSS for:

JavaScript should be introduced when actual application logic or interaction requires it.

Reducing unnecessary JavaScript usually makes interfaces more robust.

Transitions

I use CSS transitions for subtle interaction feedback.

Examples include:

Transitions should reinforce interaction.

I avoid adding animation to every property or making interfaces feel unnecessarily slow.

Motion Preferences

Some users prefer reduced motion.

Where substantial animation is used, I consider the user’s reduced-motion preference.

An interface should remain understandable without relying on animation.

Hover States

Hover is useful on pointer-based devices but should not be required for essential functionality.

Touch devices do not provide the same interaction model.

I design components so important actions remain accessible without hover.

Focus States

Keyboard users need visible focus indication.

I avoid globally removing focus outlines without providing an accessible replacement.

A focus state should be clearly visible and consistent with the visual system.

Pseudo-Classes

Modern pseudo-classes provide powerful styling possibilities.

I use them for state such as:

This keeps visual state connected directly to semantic browser state where possible.

Native Form States

Browser form controls already expose useful states.

I use CSS to communicate:

I prefer enhancing native behavior rather than replacing every form control with a custom implementation unnecessarily.

CSS Grid for Application Interfaces

Grid is particularly useful for application-style layouts containing:

These layouts can adapt from multi-column desktop structures to simpler mobile views without changing the underlying HTML significantly.

Sticky Positioning

I use sticky positioning where it genuinely improves usability.

Examples may include:

I avoid making too many interface elements sticky, especially on small screens where they can consume valuable viewport space.

Overflow

Scrollable content needs deliberate overflow handling.

I pay attention to areas such as:

An element unexpectedly overflowing the viewport is a common source of mobile layout problems.

Tables

For genuine tabular data, I use HTML tables.

I do not replace semantic tables with arbitrary grid layouts simply to achieve a particular visual appearance.

For narrow screens, I design an appropriate responsive strategy rather than destroying the relationship between headers and data.

Content-First Layout

I prefer letting real content influence layout decisions.

A design that only works with perfect placeholder text often fails once real content is entered.

I test interfaces with:

Robust layouts should tolerate all of these conditions.

WordPress

HTML and CSS remain fundamental when I work with WordPress.

Themes and builders eventually produce HTML that the browser renders.

Understanding that generated output allows me to:

I do not treat WordPress as a black box.

Bricks Builder

I use Bricks Builder as a visual development layer while still working directly with HTML and CSS concepts.

I use:

The visual editor accelerates development, but the underlying browser technologies still determine the result.

Advanced Custom Fields

ACF controls structured content.

HTML and CSS determine how that content is presented.

A dynamic field may contain:

The template still needs correct markup and layout for that data.

WooCommerce

WooCommerce interfaces require careful HTML and CSS because commerce workflows need to remain usable and accessible.

I pay attention to:

Visual customization should not make the transaction flow harder to use.

JavaScript

HTML, CSS and JavaScript have different responsibilities.

I generally think of them as:

HTML
→ structure and meaning

CSS
→ presentation and layout

JavaScript
→ behavior and application logic

Real projects naturally have overlap, but keeping these responsibilities conceptually separate leads to cleaner interfaces.

Browser APIs

When I build browser applications, HTML and CSS provide the interface around functionality powered by APIs such as:

Even technically complex applications still need a clear and usable frontend.

Progressive Enhancement

Where appropriate, I build interfaces so their basic structure remains useful before advanced JavaScript functionality is added.

This can improve:

Not every application can function fully without JavaScript, but its HTML should still represent the interface meaningfully.

SEO

HTML structure is directly relevant to search-engine understanding.

I pay attention to:

I avoid using visual presentation as a substitute for structural meaning.

Search engines consume the document structure, not the design file.

Crawlability

Important content should be represented in a form that can be understood reliably.

For content-heavy websites, I avoid unnecessary architectures that hide essential content behind fragile client-side behavior without a real technical reason.

The implementation should support both users and automated systems consuming the site.

Maintainability

The best HTML and CSS are not the most complicated.

I prefer implementations where another developer can understand:

A design system should make future changes easier rather than forcing developers to trace hundreds of isolated overrides.

Browser Compatibility

Modern browsers support an increasingly capable web platform.

I use modern CSS features when they are appropriate for the target audience.

For newer functionality, I consider:

I avoid unnecessary compatibility hacks for obsolete environments unless the project specifically requires them.

Debugging

Browser developer tools are central to my HTML and CSS workflow.

I use them to inspect:

I prefer identifying the actual cause of a layout problem rather than adding random overrides until the problem disappears.

Avoiding CSS Patchwork

A stylesheet can gradually become a chain of patches:

original rule
→ override
→ mobile override
→ later override
→ !important

I try to avoid this pattern.

When the underlying component is wrong, I prefer fixing the structure or original rule instead of endlessly adding exceptions.

HTML & CSS in My Technology Stack

I commonly use HTML and CSS alongside technologies such as:

They provide the structural and visual foundation underneath these higher-level technologies.

Why I Use HTML & CSS Directly

I use frameworks, CMS platforms and visual development tools when they improve productivity.

But I still rely on HTML and CSS knowledge underneath them.

That matters because eventually every web interface becomes:

HTML
+
CSS
+
browser behavior

Understanding that layer gives me control over semantics, accessibility, performance, responsiveness and maintainability.

It also means I am not dependent on a builder or framework to solve every frontend problem.

HTML provides the structure.

CSS provides the visual system.

Everything else builds on top of them.

That is why I consider HTML and CSS fundamental engineering tools in my web development stack rather than introductory technologies that become irrelevant once higher-level tools are introduced.