Cover of the book UI Design foundations
-40 %, Launch offer

Solid foundations for your designs

A comprehensive online book of 850 pages on the essential foundations, with in‑depth content on colors, typography, icons, media, layout, and more.

$29  $49 

Tax calculated at checkout.
14-day money-back guarantee.

Looking for answers

UI Design remains a complex field, and no matter the skill level, there are many questions that we ask ourselves throughout our careers and that I have asked myself:

“What’s the best approach to learn and do UI Design?

“Why isn’t a 140×48 px button, for example, the same actual size on all screens?”

“What’s a color space like sRGB or P3 that I see in Illustrator, Figma and other apps? Is it important? (Spoiler, yes)”

“Why, if I try to use HSL or HSB to create lightness variants, do I get unbalanced palettes?

“Why don’t all typefaces have the same actual size (whereas on Figma / Sketch I used the same value)?”

“How to choose and make good typeface pairs according to the project?”

“What are the essential principles for a good layout?

“How to make a good dark mode?

“Which resolutions should I use for my designs, and what are the best breakpoints for responsive design?”

And the list goes on...

I spent a long time looking for a resource that would answer all these questions. Sure, I purchased books on UI Design and read many articles, but none of them answered them completely.

All too often, I’d get generic advice on colors and typography, but without going into enough detail, how to design a button or a card, but not the general principles of layout, etc.

In addition, none of them talked (or very little) about the important screen characteristics, such as pixel density or color spaces with their influences throughout the UI Design process.

Finally, they were often in PDF format, which was not easy to use, for example to go to a particular page, read on mobile, get updates, etc.

It was from there that I decided to write the book “UI Design foundations” and after more than 2 years of work, many rereads and rewrites (and several liters of coffee ☕️), it’s finally here.

If I had a DeLorean with a flux capacitor, this is the book I’d take back in time and give to myself (and also a sports almanac, but that’s another story...).

Let’s have a sneak peek

A custom-made platform to read from anywhere for the pleasure of your RX (Reader eXperience ©)

16 pages from the book, extract 1
16 pages from the book, extract 2
16 pages from the book, extract 3
16 pages from the book, extract 4
16 pages from the book, extract 5
16 pages from the book, extract 6
16 pages from the book, extract 7
16 pages from the book, extract 8
16 pages from the book, extract 9
16 pages from the book, extract 10
16 pages from the book, extract 11
16 pages from the book, extract 12
16 pages from the book, extract 13
16 pages from the book, extract 14
16 pages from the book, extract 15
16 pages from the book, extract 16

Who is this book for?

This book is intended for both beginners and more advanced designers, as well as for developers who wants:

To specialize in UI Design over the long term, save time and make their work simpler.

A progressive and logical learning approach, where each chapter builds on the previous ones.

A visual-rich guide that you can consult from any page whenever you need to throughout your career.

Content that goes really in-depth, instead of quick tips like “use HSL for colors”, “texts should be 16 px minimum” or “use 12 columns for layout all the time”.

A theoretical guide specialized on the foundations of UI Design and not the rest like native designs on iOS / Android or the different styles of UI Design.

Universal principles for any type of UI Design project, such as a website, native app or web app design.

A guide on an online responsive platform that, unlike a PDF, allows you to read on any device the content with its updates without the need to download it again.

Who it isn’t for

No false hopes, it’s important to also talk about what you won’t find here. So this book is not for you if you’re looking for:

A general presentation of UI Design, in which case I recommend this article to discover the subject.

A collection of short tips, although there are some, this book takes the necessary time to properly explain all the theory on the foundations of UI Design.

A book that covers the whole field of UI Design, for example we won’t be looking at how to make certain components in particular, but rather the general principles behind them.

A practical course with exercises, this book should be seen more as a theoretical guide to foundations, to be complemented by personal practice and other content (I list several useful links for this at the end of the book).

A guide to build a design system in practice, even though I talk about design tokens (variables) and how to structure them with two types of palettes, this isn’t the heart of the book.

A course on how to use Figma, but we’ll of course be looking at the important characteristics specific to the majority of UI Design apps, such as their color spaces and units.

Requirements

Although this guide is for beginners and more advanced designers, if you’ve never opened an app like Figma or tried your hand at designing a bit, I recommend going through this first.

It’s better, indeed, if you’ve already designed a little and are reading the book in search of answers.

It that’s not the case, you can for example simply copy two or three screens from an existing design and then create a small project. I’ve listed some ideas for practice here: How to practice UX/UI Design?

This way, it’ll give you some basics on Figma (or another app like Sketch) and an overview of UI Design, which is recommended for the book.

One last sneak peek

A book rich in images and screenshots to illustrate the chapters

16 pages from the book, extract 1
16 pages from the book, extract 2
16 pages from the book, extract 3
16 pages from the book, extract 4
16 pages from the book, extract 5
16 pages from the book, extract 6
16 pages from the book, extract 7
16 pages from the book, extract 8
16 pages from the book, extract 9
16 pages from the book, extract 10
16 pages from the book, extract 11
16 pages from the book, extract 12
16 pages from the book, extract 13
16 pages from the book, extract 14
16 pages from the book, extract 15
16 pages from the book, extract 16

A progressive approach to the foundations of UI Design

What’s the best way to learn UI Design? Should we start by talking about colors? Layout? How to make a button?

An efficient way of approaching a new field to understand it better, is to disassemble it until we reach its elementary and indivisible parts, which we can then study more easily and in a logical, progressive order.

If I take a house or a building as an example, at first glance it’s a complex structure, made up of a multitude of parts with their own rules that fit and work well together.

Now, if I want to design a house myself, it’d better study how it was built by going back in time, deconstructing it to better understand all the parts that make it up and their order of assembly, so as to be able to remake something similar.

I’ll discover, among other things, that there’s a whole legal procedure to go through first, a study of the terrain, and that I’ll have to start by studying the role of the foundations and how to make them solid rather than starting with the interior decoration, and so on.

With UI Design it’s the same thing, and to answer the question at the beginning, we need to extract the fundamental parts of a UI design.

If for example we take this design:

Example of a UI design

In order, we can extract the different parts that make it up like this, and it would work for any design:

Example of a UI design disassembled

So we have a design made up of flows, which are made up of templates, themselves made up of components that are an assembly of base elements, all of which are displayed on screens and therefore subject to their constraints.

And if we go on, we realize that behind the assembly of components and templates, we also have general layout rules like creating clear groups, elevations, aligning elements, managing responsive design, etc.

Then we also have common best practices like putting the navigation at the bottom on a mobile app, structuring a form in a certain way, etc.

Then finally, we have the styles which will depend on the product’s image (including the styles of native OS designs like iOS or Android).

All this while taking into account users’ specificities, such as color blindness, visual acuity and lighting conditions.

Which gives us in detail:

  • The supports, in particular the screens on which the design will be displayed.
  • The base elements such as colors or typefaces, influenced by the screen characteristics, such as resolution, density, color space, etc.
  • Components which are assemblies of the base elements according to certain general layout rules, as well as common best practices and certain styles.
  • Templates which are assemblies of components according to the same general layout rules, as well as common best practices and certain styles.
  • Flows, which are concrete actions such as “log in” or “add to cart”, often made up of several templates and which also have certain common best practices.

Finally, all this can be organized in a design system to facilitate the creation and evolution of a UI project.

Note also that there’s usability (including accessibility), but as we’re going to see in the book, these are part of the foundation points, like having good contrasts.

What the book covers

With the parts defined above, here is the UI Design learning path in the order I recommend, including what the book covers:

UI Design learning path diagram

(* Design apps: the book talks about their choices and base configuration like color spaces, but not how to use an app like Figma or Sketch in detail.)

These six parts are what I consider the foundations of UI Design.

This is a logical order, as it’s best to look at screen characteristics first before moving on to color choices or typeface sizes, for example, as these characteristics strongly influence them.

And in practice when working on a project, this is also more or less the order I recommend. For example, before moving on to the layout, as we’ll see in the book, it’s better to have a palette with base colors and typefaces, and even icons depending on the cases.

You can see that this book doesn’t cover the whole field of UI Design, as mentioned before, it focuses on the foundations, because that’s what I feel is lacking among current books and guides.

However, at the end of the book, you’ll find links to resources for further exploration of the last three points.

Chapter contents in detail

In eight chapters, here’s everything the book covers:

1 - Supports

1.1 - Interface types
  • An overview of interface types (GUI, AR, VR, etc.) and their most popular supports.
1.2 - Means of control
  • A presentation of the different means of control such as touch surfaces with their common gestures.
1.3 - Screen characteristics
  • The relationship between screen size, resolution and density, which will have an influence throughout the book, especially on typeface sizes.
  • The difference between software pixels and hardware pixels on high-density screens.
  • Why screens need codified color spaces like sRGB and P3 and their influences on the choice of colors, design apps and also media.
  • Other characteristics such as color depth, gamma and brightness.
1.4 - Choosing a monitor
  • A guide to choosing the right external monitor for UI Design, based on important criteria such as screen technology (TN, VA, IPS, OLED), pixel density and color space.
1.5 - Screen calibration
  • How to properly calibrate your external monitor, with or without a calibration device, in order to get the best possible color rendering (a task often forgotten).

2 - Users

2.1 - Their specificities
  • The different types of color blindness, the importance of visual acuity and lighting conditions which will have an influence on many points of the book, such as defining typeface sizes or ensuring good contrasts.

3 - Design apps

3.1 - Presentation and choice
  • Why choose Figma, but also why another app like Sketch can do the job.
  • The role and importance of color profiles in the apps.
  • The difference between vector and raster design apps.
3.2 - Configuration
  • How to choose a color space according to the project and the difference between conversion and assignment if you need to change it in the middle of the process.
  • The importance of paying attention to the zoom level to avoid having a design that’s too small or too large once developed.
3.3 - Units
  • What are the differences between `px`, `dp` and `pt` and which one to use.
  • Why a unit like the millimeter isn’t possible because of pixel density.

4 - Base elements

4.1 - Introduction and design tokens
  • A presentation of design tokens (or “variables”).
  • How to group them with two types of palettes (base and functional).
  • Which base elements to define before layout.
4.2 - Shapes
  • The various shape parameters such as fill types, borders or rounded corners.
  • The various effects found in most design apps, such as drop shadows, which we’ll use later for elevations.
  • The notions of “bounding box” and “box model”.
  • The tools for creating them, in particular the pen but also the boolean operations.
  • Masks and the different blend modes.

4.3 - Colors

4.3.1 - Basics
  • How to represent colors with clear parameters.
  • The difference between saturation and chromaticity, which we also call relative and absolute chroma.
  • The difference between a color space and a color model.
  • The difference between RGB and CMYK and why we use these primary colors and not others.
  • The different RGB notations and why hexadecimal, HSL and HSB notations in Figma are misleading compared to the P3 color space.
  • An in-depth comparison of the different models with their flaws and qualities, including HSL and HSB and why it’s better to use newer models like OkLCH or LCH.
  • How to make good gradients.
4.3.2 - Application - Base colors
  • How many and how to choose the colors according to your project, for example the main color, normal and tinted grays or the four universal colors useful in many projects.
  • Why, depending on the cases, create versions for dark mode and sRGB space of these colors.
4.3.3 - Application - Lightness variants
  • How to create and name the lightness variants using different methods, in particular with OkLCH (using the OkColor plugin on Figma), but also the methods to avoid.
  • Why with certain hues such as yellow we lack saturation (or chroma) in the darker variants, and how to fix this with OkLCH.

4.4 - Typography

4.4.1 - Basics
  • The difference between copywriting and UX writing, who writes the texts and should you do some of them as a UI Designer.
  • How to categorize typefaces in a way that makes sense, as opposed to historical classifications (“Humanist”, “Didone”, “Grotesque”, etc.) not really useful in UI Design.
  • What the typeface size and line height we use in design apps or code really mean, its relationship to the bounding box, why not all typefaces have the same actual size and the important role of x-Height.
  • A presentation of all the other important parameters such as weight, letter case, letter spacing vs kerning, paragraph alignments, etc.
  • Advanced parameters such as OpenType features and variable fonts.
4.4.2 - Application - Base typefaces
  • Choosing one or more typefaces according to your project and based on the two main functions of texts in the designs.
  • Knowing when to go for free or paid typefaces.
  • When to use and when not to use OS preinstalled typefaces for a project.
  • The problem of the native vertical position specific to each typeface, which means that texts are not always properly aligned (for example in a button) and why you need to pay attention to this when choosing typefaces.
  • Detailed criteria for choosing typefaces, including their licenses, support for different languages, format, balance between legibility and personality, number of fonts, etc.
  • An approach to make good typeface pairs according to their properties and the project context.
4.4.3 - Application - Variants (parameter definition)
  • How to define the values of the important parameters and why start with the size because it influences all the others.
  • Why say that “16 px or 18 px for the base size” are still too wide averages and how to define a minimum legible size, with the help of a spreadsheet (supplied with the book) and according to various important factors such as x-Height, density and average screen distance, visual acuity and lighting conditions.
  • Which methods for defining the other sizes from this base size.
  • How to define the other parameters such as weight, letter spacing, length and number of lines, still based on the size.
  • How to define line height in detail, why percentage values aren’t the best and what’s better to use instead to get a better result (spoiler, again a matter of x-Height).
4.4.4 - Advanced
  • The fallback system and its importance in preventing the “FOUT” effect.
  • How to handle the projects with different writing systems.
  • The important typographic rules in UI Design such as the non-breaking space and the different types of single quotes and double quotes.
  • How the default line height and bounding box are calculated by design apps and browsers.

4.5 - Icons

4.5.1 - Basics
  • Where icons come from and their important roles in the history of UI Design.
  • A presentation of their different styles and parameters, including why it’s important to have icons in square areas.
  • The differences between the two main formats: vector image and icon font, and which one to choose according to the context of a project.
4.5.2 - Application
  • Choosing icons according to your project and based on their two main functions in the designs (different from typefaces).
  • How context influences the use of icons and why it should be taken into account.
  • A list of the important points to check when choosing them according to the project, such as their license, their size in a square area or not, whether the pack is complete, their legibility and understanding, etc.
  • A logical approach to naming them and which allows to evolve over the long term.
  • Why use icons with text in some cases.

4.6 - Media

4.6.1 - Basics
  • The differences between vector and raster formats.
  • The different image formats in these two categories and their important characteristics, such as SVG, JPG, PNG, WebP or Lottie.
  • The different video formats and how they are distinct from those of images, such as the difference between a container format like MP4 and the codecs it contains like H.264.
  • What bitrate is and its importance in video quality.
  • Why media have color profiles and their importance in UI Design.
4.6.2 - Application
  • The possible uses of media in UI Design and how to choose them according to the context of a project.
  • A list of the important points to check when choosing them according to the project, such as their license, legibility and understanding, quality and file size, etc.
  • The basic editing tools of design apps, such as cropping, exposure correction or background removal, for adjusting images as needed in a project.

5 - Layout

5.1 - General principles

5.1.1 - Groups
  • The four principles for making clear groups, whether for simple or complex components.
  • How to choose between a group size defined by the content or not.
5.1.2 - Elevations
  • The four approaches to simulate an elevation, including the well-known shadows.
  • How to create natural shadows that blend well into a design.
  • How to show different levels of elevation.
5.1.3 - Aspect ratios
  • The different aspect ratios and their importance for the media in a design.
5.1.4 - Alignments and grids
  • The different types of alignments and the tools in design apps to make your job easier.
  • The different types of grids, such as the flexible grid based on multiples of 4 or the strict grids based on columns (among others).
  • Which tools and grids to use, and why you need to be careful of the column grid trap.
5.1.5 - Contrasts
  • Why contrast isn’t just about colors.
  • The reasons for starting a design in grayscale.
  • A two-part approach to color contrasts with the important points and what to avoid for each.
  • How to measure it for texts according to the WCAG and APCA standards with the minimum values depending on the size and color of a text (and why it’s better to use APCA).
  • The case of contrasts with texts on complex surfaces such as images.
  • When to use contrasts of hue only, i.e. colors with the same absolute chroma value.
  • Why for size contrasts I recommend using the base size of texts as a starting point for the sizes of everything else.
5.1.6 - Optical adjustments
  • The advanced optical adjustments of weights and colors.
  • Alignment and size adjustments in relation to the perceived mass of icons and other shapes such as buttons.

5.2 - Movements and actions

5.2.1 - Movements
  • The importance of anchor points and hierarchy as well as how to use them.
  • The flow lines and directions, with their role in the layout.
  • How users scan a design by layers and the importance of having clear groups to help them.
  • The importance of rhythm and balance.
5.2.2 - Actions
  • Why actions need to have a good affordance depending on their contexts.
  • How to layout clear and accessible actions, paying attention to their hierarchies, target sizes and optimal thumb zones on smartphones.
  • The different types of scrolling.

5.3 - Responsive design

5.3.1 - Basics
  • Why responsive design goes beyond simply adapting the layout to fit the size of a screen, and what’s the question to ask in all circumstances.
  • A presentation of the seven event categories of responsive design.
  • Why just talking about breakpoints isn’t enough and a presentation of zones and design resolutions.
5.3.2 - Zones and design resolutions
  • How to define, according to the latest statistics, the zones of the main device categories without falling into the common mistake of taking well-known resolutions as limits.
  • How to choose the resolution(s) on which to make a design, depending on many important factors such as, among others, the type of the design or the characteristics of the screens where the design will be displayed.
5.3.3 - Different average screen densities and distances
  • Why adapt the overall size of a design according to the category of the device where it’s displayed.
  • Why do media like photos need several sizes to make sure they’ll look sharp on all screens (1x, 2x, 3x, etc.).
5.3.4 - Different group sizes
  • The different adaptation approaches when a group (including the screen) changes size.
  • The difference between global and local breakpoints.
  • The flexible dimensions and position constraints between breakpoints.
  • Mobile-first vs desktop-first approach.
5.3.5 - Light / dark modes and themes
  • How to make a good dark mode and why it’s not just a matter of inverting the colors of the light mode.
  • Why I talk about “mode”, what themes really are and when to use them.
5.3.6 - Dynamic texts and media
  • The importance of anticipating what happens if the texts in a design change over time, whether in content, language or their background.
  • Same thing for the media.
5.3.7 - Feedback
  • Why it’s important to give users feedback after their actions and other events.
  • The different loading approaches and which ones to use depending on the context.
  • The importance of thinking about all possible component states when designing them.
  • Why use several signals to show a state, due to color blindness and poorly adjusted screen contrasts.

6 - Asset preparation and export

6.1 - Images
  • Choosing the right format according to the type of the image and the project.
  • How to determine the number of size variants to export for the raster images with many examples.
  • Which apps to use to convert and optimize the exported images (and why it’s important).
  • How to prepare, optimize and export vector images.
  • How to create an icon font with IcoMoon if a project needs one.
6.2 - Videos
  • Choosing the right format according to the type of the project.
  • The basic actions of HandBrake app for optimizing, resizing and converting videos in a UI Design context.
  • How to determine the number of size variants to export.

7 - Usability

7.1 - Presentation
  • A presentation of usability, where accessibility fits in and why in reality we’ve already talked about it throughout the book.
  • A reminder of important principles seen in the book such as following common best practices or that not everyone sees the same design.

8 - Useful links

8.1 - List
  • A reminder of all the tools and documents custom-made for the book.
  • Links to quality resources to go further in the areas of common best practices, native designs (Apple and Google) or the different styles.

Frequently asked questions

If you got any questions, here are the answers

What do I mean by “online book”?

The book is accessible on my online reading platform: books.dokozero.design. By getting this book, you’ll have unlimited access to it (an account will be created with the email address you’ll use at the time of purchase if you do not have one).

Can I read in offline mode?

This is not possible at the moment, you’ll need an internet connection to read.

Why not a simple PDF file instead?

Unlike a PDF file, the reading platform lets you: get all the updates without having to re-download the PDF, read on mobile and in the dark with the dark mode. In addition, it would require me to use an app with different operating modes to those of the web, and would therefore take me longer to make updates.

How many pages are there in the book?

850 pages. This may sound like a lot, but in reality, the book is rich in illustrations and other captures that are quick to “read”. Moreover, it can be read non-linearly and some sections such as the advanced notions in typography, are not necessarily essential for understanding the rest.

How is the number of pages calculated?

As this is a site, to calculate the number of pages I took the total number of words in the book (206193 words) plus the average number of words per image (955 images × 100 words = 95500 words) then divided the result by the average number of words per page (350 words). This gives us a total of 862 pages, rounded up to 850 pages.

Is the content updated?

One of the main advantages of the reading platform is that it allows me to make updates easily, which is necessary since the field of UI Design evolves rapidly.

No, once you’ve bought the book, all future updates are free.

Does it make a difference if I take the book in one language or another?

None, there are not several versions, no matter if you get the book from the page of one language or another, you’ll have access to the same content, where you can also change the language freely.

I am already a UX/UI Designer will I still learn things?

That’s quite likely, indeed, in the book I talk about fairly recent points like the OkLCH color model or the APCA standard for contrasts, which are fairly recent notions in UI Design and not necessarily covered in other content on the subject.

But I can find the same information on the internet, right?

For some, yes, but more scattered and not necessarily up to date. With this book, you have a centralized, easily accessible and structured source of knowledge. In addition, there are some relatively exclusive sections, such as the detailed use of the Figma OkColor plugin created in the context of this book.

And if I’m still not satisfied?

No problem, you have 14 days from the date of purchase to get your money back (access to the book will be removed, however).

Who am I?

A computer geek from a young age, I created my first website back when the internet was limited in time and you were greeted by sweet modem music (if you don’t know what I’m talking about, you didn’t miss anything, rest assured 😉 ). For the past 10 years or so, I’ve been navigating around web development and UX/UI Design.

By using this site you agree the use of cookies. Close