```
The preset leaves numeric and `px` utilities unchanged, along with classes from unrelated scales such as `n:text-s`, `n:rounded-s` and `n:size-icon-s`. Arbitrary classes referencing legacy tokens, such as `n:p-[var(--n-space-s)]` or `n:gap-(--n-space-m)`, warn without autofixes so calculations and fallbacks can be reviewed.
The preset replaces options for the two class-migration rules. If your configuration already restricts other classes or migrates other legacy categories, merge those options with the preset's rules. Once a migrated directory is clean, retain the checks and promote them to errors without discarding their options:
```javascript
const migrationRules = nordPlugin.configs['migrate-spacing'].rules
// Append after the migration preset. Narrow files to each migrated directory.
const migratedDirectory = {
files: ['src/migrated/**/*.{ts,tsx,vue,html}'],
rules: Object.fromEntries(
Object.entries(migrationRules).map(([name, setting]) => [
name,
['error', ...setting.slice(1)],
]),
),
}
```
### CSS and inline styles
The migration preset also fixes deprecated variables in plain CSS inside Vue `
```
You can see all the available custom properties for the Banner component on [its respective docs page](https://nordhealth.design/components/banner/?example=inside+card#css-properties). Custom properties differ from component to component, refer to the component's documentation for a complete list of available custom properties.
\> \[!WARNING]
\> Always use a component's properties over a CSS custom property wherever possible. CSS Custom properties are built with a counterpart "private" property, prefixed with
\> \`
\> --\_n-
\> \`
\> . Please refrain from using private properties as they are always subject to change and intended for internal component use only.
---
### Themes
We offer light and dark [themes](https://nordhealth.design/themes/) for components in addition to high contrast variants. Themes operate at a global level, rather than per component. The [CSS Framework](https://nordhealth.design/docs/developer/css-framework/) includes the light theme by default. For theme specific documentation, please see [themes documentation](https://nordhealth.design/themes/). Make sure to try [theme playground](https://nordhealth.design/themes/playground/) as well to get familiar with theming and how to customize it.
```bash
# Install themes using NPM
npm install @nordhealth/themes --save
# Install themes using Yarn
yarn add @nordhealth/themes
```
\[]\(/themes/)\[Themes documentation]\(/themes/)
---
### Waiting for components to load
Web Components are entirely self-contained (both styles and behavior), and can be loaded/defined asynchronously. Therefore a component may not be ready for use immediately.
When a component is loading, it should be hidden from view to avoid a Flash Of Un-styled Component (see [FOUC](https://en.wikipedia.org/wiki/Flash_of_unstyled_content){rel=""nofollow""}). Our CSS framework will do this for you, as long as it is loaded *before* the components.
If you set a property/attribute on a custom element before it's loaded, it will be applied correctly and will use the values once it's loaded. However, you *cannot* call a method on a component before the component is loaded.
Most of the time this is not an issue, as you will be calling methods in event handlers etc, when the component has already loaded. In cases where you want to call a method as soon as possible, for example on page load, you need to wait for the component to be defined, using [`customElements.whenDefined`](https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/whenDefined){rel=""nofollow""}:
```html
```
---
### Code completion for VS Code
We generate TypeScript type definitions for all our Web Components. This will allow VS Code, and other editors, to offer code completion and type information for properties and methods, whether using TypeScript or not.
Refer to our specific instructions for [React](https://nordhealth.design/#types-and-editor-integration-with-react) and [Vue](https://nordhealth.design/#types-and-editor-integration-with-vue).
---
### Form controls
All our input components raise `change` events, and where it makes sense `input` events. These are useful for client-side validation, or for gathering values in javascript-based apps like with [Vue](https://nordhealth.design/#vue) or [React](https://nordhealth.design/#react).
Data inputs take a different approach to composition: they are standalone by default. A single element such as [Input](https://nordhealth.design/components/input/) bundles its label, hint and error message, so the common case works with no extra markup. When you need more control over layout, you can opt out of this built-in chrome and compose the parts yourself — place the control inside a [Field](https://nordhealth.design/components/field/), which supplies the label, helper text and error, or hide individual parts with attributes like `hide-label`. Convenient by default, composable when you need it.
```html
```
For server-rendered apps, our components hook into the browser's [`formdata`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLFormElement/formdata_event){rel=""nofollow""} event, which means that our components' values will be submitted as part of POST/GET traditional form submissions, like native HTML elements:
```html
```
The browser's built-in [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData){rel=""nofollow""} object can also be used to get all values from a form via JavaScript:
```html
```
---
### Localization
Nord provides a lightweight solution for localizing its components. Not all components need localizing, as for the most part snippets of text are set per instance. For example, the label on an [Input](https://nordhealth.design/components/input) will likely be changed every time you use it. Those cases are an app-level concern.
However, some components have text which has no reason to change per instance. For example, the usage instructions in the footer of the [Command menu](https://nordhealth.design/components/command-menu/), or the accessible labels for next/previous month buttons of the [Calendar](https://nordhealth.design/components/calendar/).
For the latter cases, we provide a localization mechanism. It is not possible or feasible for Nord to anticipate every locale in which the components might be consumed, so we rely on individual teams and applications to translate and configure localization. To ensure Nord components work out of the box, we bundle translations for `en-US`.
\[View localization documentation]\(/docs/developer/localization/)
---
## React
As of version 19, React has [excellent support](https://custom-elements-everywhere.com/#react){rel=""nofollow""} for Web Components. They can now be used directly, with no [wrappers](https://nordhealth.design/#react-wrappers) or setup necessary.
\[View example React project]\(https\://github.com/nordhealth/react-example-project)
### Installation
Install with npm:
```bash
npm install @nordhealth/components @nordhealth/css --save
```
or yarn:
```bash
yarn add @nordhealth/components @nordhealth/css
```
### Usage
Import the `@nordhealth/components` and `@nordhealth/css` packages in your main entry point:
```jsx
// main.jsx
import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import App from './App.jsx'
import './index.css'
import '@nordhealth/css'
import '@nordhealth/components'
createRoot(document.getElementById('root')).render(
)
```
Then you can use the Nord's components throughout your app. For instance, here is an example using a JSX component:
```js
import { useState } from 'react'
function CounterButton() {
const [count, setCount] = useState(0)
return (
<>
setCount(count + 1)}>
Clicks:
{' '}
{count}
>
)
}
export default CounterButton
```
For optimal tree shaking, don't import the `@nordhealth/components` package in the main entry point. Instead, import the specific Nord components you're using in each component. For example:
```js
import { useState } from 'react'
import '@nordhealth/components/lib/Button'
function CounterButton() {
const [count, setCount] = useState(0)
return (
<>
setCount(count + 1)}>
Clicks:
{' '}
{count}
>
)
}
export default CounterButton
```
The following example shows how to use refs in a TypeScript application:
```tsx
import type { Input } from '@nordhealth/components'
import { useRef } from 'react'
function FocusInput() {
const inputRef = useRef
(null)
return (
<>
inputRef.current?.focus()} variant="primary">
Focus input
>
)
}
export default FocusInput
```
React requires that event listeners for Web Components use the event name **verbatim**. For instance, if a Web Component has an event named `exampleEvent`, you must listen for the `onexampleEvent` event. If a Web Component has an event named `example-event`, you must listen for the `onexample-event` event. This is unusual for React, which typically expects events to be like `onExampleEvent`. For example, this is how you would listen to the [`nord-focus-date` event of the Calendar component](https://nordhealth.design/components/calendar#events):
```js
import { useState } from 'react'
function Calendar() {
const [focusedDate, setFocusedDate] = useState('')
return (
<>
Focused date:
{focusedDate}
setFocusedDate(
e.date.toLocaleDateString('en', {
year: 'numeric',
month: 'long',
day: 'numeric',
})
)}
>
>
)
}
export default Calendar
```
\> \[!WARNING]
\> Note: For events that have the same name as a native event, you can still use the syntax you would expect. For example,
\> \`
\> onChange
\> \`
\> or
\> \`
\> onInput
\> \`
\> .
### Types and editor integration with React
Nord's components work out of the box with React, but they don't provide any TypeScript support or editor integration. To improve the developer experience, we offer React-specific types for our components. They allow you to get IntelliSense for Nord components in JSX. Both in TypeScript and JavaScript projects.
To integrate these into your project, install `@nordhealth/components` as you normally would. Then add the following to your `tsconfig.json` in a TypeScript project, or `jsconfig.json` in a JavaScript project:
```json
{
"compilerOptions": {
"types": ["@nordhealth/components/lib/react.d.ts"]
}
}
```
Now you should get full type support for Nord components in your React project. Including IntelliSense for Nord components in JSX.
### Server-side rendering (SSR) with React
Nord components can be imported in non-browser environments, for *shallowly* rendering on the server (within Next.js, for example). That is, the Nord component's tag and attributes set via JSX will be rendered, but the component's shadow DOM with all the styles and HTML in it will not be rendered on the server.
You might get hydration mismatch errors for some components, since Nord components reflect default values for properties to attributes after being defined, and some render to the light DOM. You can resolve these hydration mismatch errors by disabling server-side rendering for the component, or by adding `suppressHydrationWarning` to the component.
If you are using Next.js App Router, you must make sure any Nord components you import are beyond the `"use client";` boundary.
\> \[!WARNING]
\> Note: we currently don't support server-side rendering of Nord components with the shadow DOM included.
### React wrappers
Whilst React supports Web Components, they were very awkward to use as-is [before React 19](https://react.dev/blog/2024/12/05/react-19#support-for-custom-elements){rel=""nofollow""}. For this reason, we provide React-specific wrapper components in the package `@nordhealth/react`. This will allow you to use the Nord components as you would any other React component.
\> \[!WARNING]
\> Note: React 19 makes these wrapper components unnecessary, so the
\> \`@nordhealth/react\`
\> package has been deprecated and will be removed in the next major release.
\>
\>
\>
\>
\> For now,
\> \`@nordhealth/react\`
\> will continue to receive updates as its build is fully automated, but you should start planning on utilizing the
\> \`@nordhealth/components\`
\> package directly where possible.
\>
\>
\>
\>
\> To continue having full type checking and auto-completion in your JSX, you can use
\> \[the new type definition file for React]\(#types-and-editor-integration-with-react)
\> .
Install with npm:
```bash
npm install @nordhealth/react @nordhealth/css --save
```
or yarn:
```bash
yarn add @nordhealth/react @nordhealth/css
```
You must import `@nordhealth/css` once in your main entry point, then import components from `@nordhealth/react` wherever they are needed:
```jsx
import { Button } from '@nordhealth/react'
import { useState } from 'react'
import { createRoot } from 'react-dom/client'
import '@nordhealth/css'
function App() {
const [count, setCount] = useState(0)
return (
)
}
const root = createRoot(document.querySelector('#app'))
root.render(
)
```
The React wrapper components forward their refs, so that you can get access to the underlying web component instance with `useRef`. The `@nordhealth/react` package also exports types for all the Web Components for convenience.
The following example shows how to use refs in a TypeScript application:
```tsx
import type { InputWC } from '@nordhealth/react'
import { Button, Input } from '@nordhealth/react'
import { useRef } from 'react'
import { createRoot } from 'react-dom/client'
import '@nordhealth/css'
function App() {
const inputRef = useRef
(null)
function handleClick() {
inputRef.current?.focus()
}
return (
<>
>
)
}
const root = createRoot(document.querySelector('#app'))
root.render()
```
### Disabling server-side rendering within Next.js
If you are using the React wrapper components within Next.js, then the easiest way of disabling server-side rendering is by importing them from our Next.js specific integration:
```js
// instead of:
import { Button } from "@nordhealth/react"
// do this:
import { Button } from "@nordhealth/react/lib/next.js"
```
This creates [dynamic imports with `ssr` set to `false`](https://nextjs.org/docs/app/building-your-application/optimizing/lazy-loading#skipping-ssr){rel=""nofollow""} for you, so they only get loaded on the client side.
If you are using Next.js App Router, you must make sure any Nord components you import are beyond the `"use client";` boundary.
\> \[!WARNING]
\> Note: the
\> \`@nordhealth/react\`
\> package (which includes the Next.js integration) has been deprecated and will be removed in the next major release.
---
## Vue
Vue has [excellent support](https://custom-elements-everywhere.com/#vue){rel=""nofollow""} for Web Components out of the box, it only requires a little configuration.
\[View example Vue project]\(https\://github.com/nordhealth/vue-example-project)
### Installation
Install with npm:
```bash
npm install @nordhealth/components @nordhealth/css --save
```
or yarn:
```bash
yarn add @nordhealth/components @nordhealth/css
```
### Configuration
Vue needs to be configured to recognize Web Components. If you're using Vite, it can be done like this:
```js
// vite.config.js
import vue from '@vitejs/plugin-vue'
export default {
plugins: [
vue({
template: {
compilerOptions: {
// treat all tags with a dash as custom elements
isCustomElement: tag => tag.includes('-')
}
}
})
]
}
```
For more information, and how to configure for other setups (e.g. Vue CLI), please see the [Vue docs](https://vuejs.org/guide/extras/web-components.html#using-custom-elements-in-vue){rel=""nofollow""}.
### Usage
Import the `@nordhealth/components` and `@nordhealth/css` packages in your main entry point:
```js
import { createApp } from 'vue'
import App from './App.vue'
// main.js
import '@nordhealth/css'
import '@nordhealth/components'
createApp(App).mount('#app')
```
Then you can use the Nord's components throughout your app. For instance, here is an example using a single-file component:
```html
Count is: {{ count }}
```
For optimal tree shaking, don't import the `@nordhealth/components` package in the main entry point. Instead, import the specific Nord components you're using in each component. For example:
```html
Count is: {{ count }}
```
Our components also support the [`v-model`](https://vuejs.org/api/built-in-directives.html#v-model){rel=""nofollow""} directive for two-way data binding:
```html
```
However, for our [Checkbox](https://nordhealth.design/components/checkbox/), [Toggle](https://nordhealth.design/components/toggle/), and [Tag](https://nordhealth.design/components/tag/) components you need to add `type="checkbox"` to get [`v-model`](https://vuejs.org/api/built-in-directives.html#v-model){rel=""nofollow""} working. Otherwise, Vue has no way of knowing that it should bind to the `checked` property instead of the `value` property. For example:
```html
```
Alternatively, you can always use the more verbose equivalent to [`v-model`](https://vuejs.org/api/built-in-directives.html#v-model){rel=""nofollow""}:
```html
```
Sometimes, you may need to pass complex data such as objects, arrays, and functions. These must be passed to a Web Component as *properties* rather than *attributes*. For the most part, Vue does the correct thing, and will handle this without any particular treatment.
However, there may be rare cases where you need to be more explicit that you're supplying a property. For this, Vue has the syntax `.propName="value"`, where `propName` is the name of the property.
For instance, here is an example of passing a function to a component:
```html
```
You can integrate Nord components with RouterLink components from Vue Router like this:
```html
{{ route.fullPath }}
```
Check out [the Vue Router](https://router.vuejs.org/api/#custom){rel=""nofollow""} documentation for more information.
### Styling
Because our Web Components come with their styles built in, and our [CSS Framework](https://nordhealth.design/docs/developer/css-framework/) comes with [utility helpers](https://nordhealth.design/docs/developer/css-framework/#utilities), you should very rarely need to add CSS to Vue components. However, if you need to add custom styles, please use our [tokens](https://nordhealth.design/tokens/) instead of fixed values and add scoped CSS within [Single-File Components](https://vuejs.org/guide/scaling-up/sfc.html){rel=""nofollow""}:
```html
Status
```
Using the `scoped` attribute will ensure the styles don't leak out of your component and affect other components.
Check out [the official Vue](https://vuejs.org/api/sfc-css-features.html){rel=""nofollow""} documentation for more information.
### Types and editor integration with Vue
Nord's components work out of the box with Vue, but they don't provide any TypeScript support or editor integration. To improve the developer experience, we offer Vue-specific types for our components. They allow you to get IntelliSense for Nord components in templates of Vue Single-File Components. Both in TypeScript and JavaScript projects.
To integrate these into your project, install `@nordhealth/components` as you normally would. Then add the following to your `tsconfig.json` in a TypeScript project, or `jsconfig.json` in a JavaScript project:
```json
{
"compilerOptions": {
"types": ["@nordhealth/components/lib/vue.d.ts"]
}
}
```
Now you should get full type support for Nord components in your Vue project. Including IntelliSense for Nord components in templates of Vue Single-File Components.
\> \[!WARNING]
\> Note: previously these types lived in a dedicated
\> \`
\> @nordhealth/vue
\> \`
\> package, but this package has been deprecated and will be removed in the next major version.
\>
\>
\>
\>
\> For now,
\> \`@nordhealth/vue\`
\> will continue to receive updates as its build is fully automated, but you should start planning on utilizing the new
\> \`@nordhealth/components/lib/vue.d.ts\`
\> type definition file instead.
### Server-side rendering (SSR) with Vue
Nord components can be imported in non-browser environments, for *shallowly* rendering on the server (within Nuxt, for example). That is, the Nord component's tag and attributes set via the Vue template will be rendered, but the component's shadow DOM with all the styles and HTML in it will not be rendered on the server.
You might get hydration mismatch errors for some components, since Nord components reflect default values for properties to attributes after being defined, and some render to the light DOM. You can resolve these hydration mismatch errors by disabling server-side rendering for the component, or by using the [data-allow-mismatch](https://vuejs.org/api/ssr.html#data-allow-mismatch){rel=""nofollow""} attribute on the component.
\> \[!WARNING]
\> Note: we currently don't support server-side rendering of Nord components with the shadow DOM included.
---
## Can I use this in my own project?
Nord Design System is solely meant for building digital products and experiences for [Nordhealth](https://nordhealth.com/){rel=""nofollow""}. Please see the [terms of use](https://nordhealth.design/resources/terms/) for full license details.
---
## Support
Need help with our Web Components? Please head over to the [Support page](https://nordhealth.design/resources/support/) for more guidelines and ways to contact us.
---
## Attribution
Special thanks to the following projects that help make Nord possible.
- Components are built with [Lit](https://lit.dev/){rel=""nofollow""}.
- Component metadata is generated by the [Custom Elements Manifest Analyzer](https://github.com/open-wc/custom-elements-manifest){rel=""nofollow""}.
- Documentation is powered by [Nuxt Content](https://content.nuxt.com/){rel=""nofollow""}.
# Webfonts
\*Get started with Nord Design System’s Webfonts that are designed to be used in combination with our CSS Framework to provide a consistent look and feel across all of our products.\*
## Integration
Integrating Nord Design System’s Webfonts into your project is straightforward. You can start using our webfonts immediately by adding the below tag to the `` of your application.
```html
```
While not recommended for normal use, you can also self-host Nord Design System’s Webfonts by following the instructions below. This might be required in cases where your application is running inside a sandboxed environment or similar.
\> \[!WARNING]
\> Please note that in most cases you will want to install our \[CSS Framework]\(/docs/developer/css-framework/) instead of Webfonts package directly. CSS Framework imports this package internally and gives you wide range of shorthand utility classes to modify an element's appearance in your application.
---
## Installing Webfonts
Before moving further with the installation, please make sure you have [Node.js](https://nodejs.org/en/){rel=""nofollow""} installed on your machine. You can install the latest version through their website.
If you’re planning on using Nord Design System’s Webfonts in a project that doesn’t yet use [Node Package Manager](https://www.npmjs.com){rel=""nofollow""}, you’ll have to first create a [package.json](https://docs.npmjs.com/files/package.json){rel=""nofollow""} file. To do this, run `npm init` and follow the steps provided. Once finished, you can install Nordhealth’s Fonts by following the instructions below.
### Install using NPM
Run in your project or website root directory (where package.json lives):
```bash
npm install @nordhealth/fonts
```
### Install using Yarn
Run in your project or website root directory (where package.json lives):
```bash
yarn add @nordhealth/fonts
```
---
## Usage
Nord Design System’s Webfonts ship with font files and CSS to self-host them. While you can use [Webpack](https://webpack.github.io/){rel=""nofollow""} or similar build tool to require the fonts, the easiest way is to install `copyfiles` NPM package and copy the files over:
```bash
npm install copyfiles --save-dev
```
Once installed, add a script to your package.json that copies the fonts from our package into a location you’ve specified:
```jsonc
"scripts": {
"copy:fonts": "copyfiles --flat node_modules/@nordhealth/fonts/lib/* src/SPECIFY_YOUR_PATH"
}
```
You can call this script while starting up your app to make sure you’ve always got the latest fonts copied over. If you're using an UNIX-like environment, you can use `&` as the separator:
```jsonc
"start": "copy:fonts & dev"
```
Otherwise, if you need a cross-platform solution, use [npm-run-all module](https://www.npmjs.com/package/npm-run-all){rel=""nofollow""}:
```jsonc
"start": "npm-run-all copy:fonts dev"
```
### Import in SCSS
Once you have fonts installed, you can import them in your project. Nord Design System’s Webfonts provide both SCSS and Less helpers to do this. To import the fonts in SCSS, include this in the beginning of your main SCSS partial:
```scss
// Sets correct path to font files
$nord-font-path: '/assets/fonts';
// Import fonts
@import '../../node_modules/@nordhealth/fonts/lib/fonts.scss';
```
You may need to edit the paths shown above depending on your setup. If you’re using Webpack, you can further simplify the above to:
```scss
// Sets correct path to font files
$nord-font-path: '/assets/fonts';
// Import fonts
@import '~@nordhealth/fonts/lib/fonts.scss';
```
Nord Design System’s Webfonts also provide a way to control the font loading technique using [CSS font-display](https://developer.mozilla.org/en-US/Web/CSS/@font-face/font-display){rel=""nofollow""}. This allows you to adjust the load performance of your app:
```scss
// Change the font loading technique
// auto, block, swap, fallback, optional
$nord-font-display: auto;
```
\> \[!WARNING]
\> When you've imported the fonts in your project, you should use the font-families and font-weights defined in \[Design Tokens]\(/tokens/) as its API and naming conventions match the ones used in Nord Design System's Webfonts package.
### Import in Less
To import fonts in Less, include this in the beginning of your main Less partial:
```less
// Sets correct path to font files
@nord-font-path: '/assets/fonts';
// Import fonts
@import '../../node_modules/@nordhealth/fonts/lib/fonts.less';
```
### Import in CSS
You can also import fonts in plain CSS directly from the [Nord CDN](https://nordhealth.design/docs/developer/cdn/). Include this in the beginning of your head:
```html
```
---
## Can I use the Webfonts in my own project?
Nord Design System is solely meant for building digital products and experiences for [Nordhealth](https://nordhealth.com){rel=""nofollow""}. Please see the [terms of use](https://nordhealth.design/resources/terms/) for full license details.
---
## Getting support
Need help with our Webfonts? Please head over to the [Support page](https://nordhealth.design/resources/support/) for more guidelines and ways to contact us.
# Content Delivery Network
\*Nord Design System serves all of its packages via a Content Delivery Network for better performance and stability. Nord CDN also makes it faster to implement and use our packages in production.\*
A Content Delivery Network (CDN) is a group of geographically distributed servers that speed up the delivery of web content by bringing it closer to where users are. CDNs cache content like web pages, images, and video in proxy servers near to your physical location. Some of the benefits of using Nord’s CDN includes:
- Faster load times and better performance for all users
- CDN scales more rapidly during heavy traffic
- Minimizes risk of traffic spikes at point of origin, ensuring stability
- Decreases infrastructure costs due to traffic offloading
- Faster to get up and running with development work
---
## Available packages
The following packages are available for usage via Nord CDN:
- **[Web Components](https://nordhealth.design/components/):** `https://nordcdn.net/ds/components/`
- **[Design Tokens](https://nordhealth.design/tokens/):** `https://nordcdn.net/ds/tokens/`
- **[Themes](https://nordhealth.design/themes/):** `https://nordcdn.net/ds/themes/`
- **[Webfonts](https://nordhealth.design/docs/developer/webfonts/):** `https://nordcdn.net/ds/fonts/`
- **[CSS Framework](https://nordhealth.design/docs/developer/css-framework/):** `https://nordcdn.net/ds/css/`
- **[Nordicons](https://nordhealth.design/icons/):** `https://nordcdn.net/ds/icons/`
- **[Color Utilities](https://nordhealth.design/design/foundations/color-utilities/):** `https://nordcdn.net/ds/color/`
- **[Ag Theme Nord](https://nordhealth.design/components/table/#recommendation-for-component-based-libraries):** `https://nordcdn.net/ds/ag-theme-nord/`
---
## URL structure
Nord CDN uses the following URL structure for the hosted packages:
```html
https://nordcdn.net/ds///
```
To fetch e.g. the Webfonts using the above format, you would write it like:
```html
https://nordcdn.net/ds/fonts/2.0.0/fonts.css
```
- To find URLs for Webfonts, see [Webfonts documentation](https://nordhealth.design/docs/developer/webfonts/)
- To find URLs for Design Tokens, see [Design Tokens documentation](https://nordhealth.design/tokens/#usage)
- To find URLs for Themes, see [Themes documentation](https://nordhealth.design/themes/)
- To find URLs for Nordicons, see [Nordicons documentation](https://nordhealth.design/icons/)
- To find URLs for Color Utilities, scroll down.
- To find URLs for AG Theme Nord, scroll down.
---
## Subresource Integrity
Subresource Integrity is a security feature that enables browsers to verify that resources they fetch from a CDN are delivered without unexpected manipulation. It works by allowing you to provide a cryptographic hash that a fetched resource must match ([source: MDN](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity){rel=""nofollow""}).
Our documentation automatically provides cryptographic hashes for the latest available package versions. To enable SRI verification, use the following tags in the `` of your application:
### Design Tokens
```html
```
### Webfonts
```html
```
### Web Components
```html
```
### CSS Framework
```html
```
### Nordicons
```html
```
### Themes
::div{.n-theme-nord}
::
::div{.n-theme-nord-high-contrast}
::
::div{.n-theme-nord-dark}
::
::div{.n-theme-nord-dark-high-contrast}
::
### Color Utilities
```html
```
### AG Theme Nord
```html
```
---
## Available versions
Nord CDN includes versioned releases of the following packages starting from:
- **@nordhealth/tokens:** `1.0.0` and newer
- **@nordhealth/themes:** `2.0.0` and newer
- **@nordhealth/fonts:** `2.0.0` and newer
- **@nordhealth/components:** `1.0.0-alpha.23` and newer
- **@nordhealth/css:** `1.0.0-alpha.0` and newer
- **@nordhealth/color:** `1.0.0` and newer
- **@nordhealth/ag-theme-nord:** `1.0.0` and newer
---
## Can I use Nord CDN in my own project?
Nord Design System is solely meant for building digital products and experiences for [Nordhealth](https://nordhealth.com){rel=""nofollow""}. Please see the [terms of use](https://nordhealth.design/resources/terms/) for full license details.
## Getting support
Need help with Nord CDN? Please head over to the [Support page](https://nordhealth.design/resources/support/) for more guidelines and ways to contact us.
# Localization
\*Localization is the process of adapting a product's translation to a specific country or region. Our team is committed to providing a high-quality experience for all our international users.\*
Nord provides a lightweight solution for localizing its components. Not all components need localizing, as for the most part snippets of text are set per instance. For example, the label on an [Input](https://nordhealth.design/components/input) will likely be changed every time you use it. Those cases are an app-level concern.
However, some components have text which has no reason to change per instance. For example, the usage instructions in the footer of the [Command menu](https://nordhealth.design/components/command-menu/), or the accessible labels for next/previous month buttons of the [Calendar](https://nordhealth.design/components/calendar/).
For the latter cases, we provide a localization mechanism. It is not possible or feasible for Nord to anticipate every locale in which the components might be consumed, so we rely on individual teams and applications to translate and configure localization. To ensure Nord components work out of the box, we bundle translations for `en-US`.
## How does it work?
We observe the [`lang`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang){rel=""nofollow""} attribute on the `` element of a page, and use this to decide which translations to use for components. If a matching translation is found, the components will use this. Otherwise, the components will fall back to using the built-in `en-US` translations.
For this reason, it is imperative that you correctly set the `lang` attribute on the `` element. Not doing so is considered an accessibility failure, and will also cause unexpected or incorrect localization of components.
We use a [`MutationObserver`](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver){rel=""nofollow""} to observe and respond to changes to the `lang` attribute on ``. So whilst you can do a full page reload whenever the language is changed, we also support changing languages on the fly without a full reload.
In addition to setting the `lang` attribute on ``, you can also set the `lang` attribute on individual Nord components if you need to override the document language for specific use cases. When set on a component, it will create its own `MutationObserver` to monitor and respond to changes to the `lang` attribute. Use this feature sparingly, as it can impact performance if overused.
## Registering translations
To add a translation, we provide a `registerTranslation` function, which accepts an object containing localized text for a specific language/region.
```js
import { registerTranslation } from '@nordhealth/components'
registerTranslation({
$lang: 'fi',
$name: 'Suomi',
$dir: 'ltr',
// translations go here
})
```
For a full example of a real world translation, see the [example translation](https://nordhealth.design/#example-translation) section.
If you use TypeScript, we export a `Translation` type which will guide you in creating translations, and will raise compile time errors if you are missing any pieces of text:
```ts
import { registerTranslation, Translation } from '@nordhealth/components'
const yourTranslation: Translation = {
// translation goes here
}
registerTranslation(yourTranslation)
```
For convenience you can also register multiple translations at once:
```ts
import { registerTranslation, Translation } from '@nordhealth/components'
const fi: Translation = { /* translation */}
const no: Translation = { /* translation */}
registerTranslation(fi, no)
```
You may have to support many languages, and not want to pay the cost of registering all translations on page load. In this case, you can register translations as needed, by [dynamically importing](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#dynamic_imports){rel=""nofollow""} your translations modules:
```ts
import { registerTranslation } from '@nordhealth/components'
function loadTranslation(lang) {
import(`path/to/your/translations/${lang}.js`).then(({ default: translation }) => registerTranslation(translation))
}
someDropdown.addEventListener('change', (e) => {
const lang = e.target.value
loadTranslation(lang).then(() => {
document.documentElement.lang = lang
})
})
```
### Partial translations
You don't need to provide all translation keys when registering a translation. It's safe to register **partial translations** with only the fields you're changing. Missing fields will be merged with existing translations.
> **Only `$lang` is required.** The `$name` and `$dir` properties are optional in partial translations and will be preserved from the existing translation if not provided.
```ts
import { registerTranslation, type PartialTranslation } from '@nordhealth/components'
// Minimal: Only provide $lang and the fields you're changing
const partialEnglish: PartialTranslation = {
$lang: 'en',
'nord-command-menu': {
placeholder: 'Search clients by name, ID, email, phone...',
},
}
registerTranslation(partialEnglish)
```
Or with full metadata (also supported):
```ts
const partialEnglish: PartialTranslation = {
$lang: 'en',
$name: 'English',
$dir: 'ltr',
'nord-command-menu': {
placeholder: 'Search clients by name, ID, email, phone...',
},
}
registerTranslation(partialEnglish)
```
After registering a partial translation:
- Only the fields you provide are updated
- All other fields are preserved from the existing translation (or defaults)
- Other components like `nord-calendar`, `nord-modal` remain unchanged
- Function values (like `noResults` callbacks) are properly preserved
- `$name` and `$dir` are preserved from existing registration if not provided
This approach is fully supported and tested. You can safely update a single translation field without needing to specify all keys.
## Example translation
Each translation has the following top-level properties:
- `$lang`: the language code for the translation. This should conform to the expected values of the [`lang`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/lang){rel=""nofollow""} attribute.
- `$name`: a human-readable name for the translation.
- `$dir`: the writing direction of the language. The value for this must either be `"ltr"` or `"rtl"`.
Other top-level properties correspond to the component name in which the text is used, and below that the identifiers for individually translated snippets.
Note that there are a mix of strings, arrays, and functions as values. This is to give maximum flexibility when translating, and to allow for properly handling language-specific grammar.
Below is an example translation for the Finnish locale, which can be used as a reference:
```js
export default {
'$lang': 'fi',
'$name': 'Suomi',
'$dir': 'ltr',
'nord-command-menu': {
instructions: 'Paina \'Enter\' vahvistaaksesi valinnan tai \'Escape\' peruuttaaksesi',
inputLabel: 'Kirjoita komento jonka haluat suorittaa.',
footerArrowKeys: 'Siirry',
footerEnterKey: 'Valitse',
footerEscapeKey: 'Esc sulje',
footerBackspaceKey: 'Siirry takaisin',
noResults: searchTerm => `Ei tuloksia haulle "${searchTerm}"`,
tip: 'Vinkki: jotkin haut vaativat tarkan hakutermin. Koita kirjoittaa koko hakutermi kokonaisuudessaan, tai kokeile toista sanaa tai fraasia.',
placeholder: 'Kirjoita komento tai hakusana…',
},
'nord-calendar': {
prevMonthLabel: 'Edellinen kuukausi',
nextMonthLabel: 'Seuraava kuukausi',
monthSelectLabel: 'Kuukausi',
yearSelectLabel: 'Vuosi',
},
'nord-date-picker': {
modalHeading: 'Valitse päivämäärä',
closeLabel: 'Sulje ikkuna',
buttonLabel: 'Valitse päivämäärä',
selectedDateMessage: 'Valittu päivämäärä on',
},
'nord-modal': {
closeLabel: 'Sulje ikkuna',
},
'nord-nav-toggle': {
label: 'Näytä/Piilota valikko',
},
'nord-textarea': {
remainingCharacters: remaining => `${remaining} merkkiä jäljellä`,
},
'nord-notification': {
dismissLabel: 'Sulje ilmoitus',
},
'nord-message': {
unreadLabel: 'Lukematon',
},
'nord-tag': {
removeLabel: 'Poista',
},
}
```
## Localization framework integration
You can integrate the Nord translations easily with a localization framework by writing a wrapper around it.
The following TypeScript example integrates with [i18next](https://www.i18next.com/){rel=""nofollow""}:
```ts
import type { Translation } from '@nordhealth/components'
import i18next from 'i18next'
import { useSupportedLocales } from './useSupportedLocales.js'
export function useNordTranslation(locale: string) {
const supportedLocales = useSupportedLocales()
// we want to fix the t function, so that it always matches the given locale,
// allowing us to control when the translations are switched over
const t = i18next.getFixedT(locale)
const translation: Translation = {
'$lang': locale,
'$name': supportedLocales[locale].name,
'$dir': supportedLocales[locale].dir,
'nord-command-menu': {
placeholder: t('common.nordComponents.commandMenu.placeholder'),
instructions: t('common.nordComponents.commandMenu.instructions'),
inputLabel: t('common.nordComponents.commandMenu.inputLabel'),
footerArrowKeys: t('common.nordComponents.commandMenu.footerArrowKeys'),
footerEnterKey: t('common.nordComponents.commandMenu.footerEnterKey'),
footerEscapeKey: t('common.nordComponents.commandMenu.footerEscapeKey'),
footerBackspaceKey: t(
'common.nordComponents.commandMenu.footerBackspaceKey'
),
noResults: (searchTerm: string) =>
t('common.nordComponents.commandMenu.noResults', {
searchTerm,
}),
tip: t('common.nordComponents.commandMenu.tip'),
},
}
return translation
}
```
---
## Support
Need help with localization? Please head over to the [Support page](https://nordhealth.design/resources/support/) for more guidelines and ways to contact us.
# Launching Nord Design System
# How we use Custom Properties in Web Components
# December, 2021
You’re reading the sixth Nord Design System monthly update. This month we’ve grown the team, further expanded on our components and began growing our CSS Framework.
Hey folks, Dave here standing in for Ariel to bringing you some updates on what's been happening this month.
## CSS Framework
I guess one of the things that’s happened this month is that I joined the team. And with that I’ve been delving into the Nordhealth design system to see how I can contribute. At present the [CSS Framework](https://nordhealth.design/docs/developer/css-framework/) is quite bare bones so I’ve been spending some time to expand on this framework to make it more useful for everyone.
There’s many things to consider when working on our CSS Framework. We want to strike a balance between useful, light-weight and approachable. It needs to be really helpful when building out the majority of the front-end, but not bloated to the extent that it’s detrimental to performance. It also needs to make sense, with class names that can be parsed without much guesswork.

We’re trying to reduce guesswork in our documentation too, by providing semantic examples that fit with the utility being shown. For example the documentation for our typographic sizing is shown with various heading levels, further reducing the guesswork around semantic HTML. However this is merely a suggestion, the CSS Framework is also intended to be flexible with the way you want to work.
It’s still a work in progress but we’ve accomplished a lot in a fairly short space of time. The CSS Framework currently includes a series of utility classes that refer back to our [design tokens](https://nordhealth.design/tokens/), but it’ll soon contain utilities for setting out all your typography, laying out stacked lists of components and a reset utility to give you a clean slate to work with.
I’ve really enjoyed collaborating with the team on this one, and I hope that energy is reflected in the quality of the framework once it's out in the wild.
\[View documentation]\(/css/)
---
## New this month
\*\[Video: /img/updates/command-menu-demo.mov]\*
Plenty of new components this month, including the extremely impressive [Command Menu](https://nordhealth.design/components/command-menu/) (shown above). We’ve had the addition of a [Spinner](https://nordhealth.design/components/spinner/) and [Icon](https://nordhealth.design/components/icon/) component as well as form entry components such as [Input](https://nordhealth.design/components/input/) and [Textarea](https://nordhealth.design/components/textarea/).
There’s lots to unpack in these components so I’ll leave Nick and Ariel the opportunity to go into more detail on another occasion.
\[View documentation]\(/components/)
---
As a newcomer to the team it’s been super interesting to see what’s been achieved within the design system and what’s next on the list. Also been very satisfying to contribute so soon after joining the team.
I’m going to keep things short but sweet, so you can get back to enjoying time with family and friends as we round off the year.
Happy Holidays!
— Dave
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# February, 2021
You’re reading the first ever Nord Design System monthly update. We’re just starting our design systems journey at Nordhealth and have created this documentation platform to support these efforts.
The aim of this platform is to serve as a hub for [Nordhealth’s](http://nordhealth.com){rel=""nofollow""} user interface design and frontend development work in the future. We’re pushing towards automating most parts of the documentation creation, but you should also expect to see manually crafted design guidelines, development tutorials, and similar here in the future.
To stay up to date with the latest [releases](https://nordhealth.design/changelogs) and [updates](https://nordhealth.design/updates/) from our design systems team, you can follow the [what’s new](https://nordhealth.design/changelogs) section that includes our current roadmap and any future updates we might release.
Currently, our main focus has been on brand refresh, exploring the overall visual direction, how the theming system works, and also creating the underlying technical architecture to support the work that follows.
Our draft style guide looks like this:
{.provet}{.diarium}
We’ve also started exploring components a little and how they could behave and look like. Here’s a concept on navigation that we’ve also tested on the documentation itself:

Last week, we also published the very first production ready design systems package, [Nord Webfonts](https://nordhealth.design/changelogs/webfonts), which includes our UI typefaces and related tools to utilize them:
### Nord Webfonts 1.0.1
- Initial release of `@nordhealth/fonts` which includes **Nordhealth Sans** and **Nordhealth Mono.** For documentation and usage guidelines, please see [Webfonts](https://nordhealth.design/docs/developer/webfonts/).
- Makes `@nordhealth/fonts` package completely independent from `@nordhealth/tokens`.
- Can now be used standalone without any other package from Nord.
- Release date 11.2.2021.
We’ve also started drafting Nord Design Tokens which you can [browse here](https://nordhealth.design/tokens/). The early token views are shown below:
{.provet}{.diarium}
If you liked this update, please consider subscribing to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
**P.S. Our team is hiring, [view open positions](https://nordhealth.design/resources/careers/) to apply.**
Until the next time!
— Ariel
# Nord Design System architecture
You’re reading the eigth Nord Design System monthly update. This month I wanted to give a little more insight into how we’ve architectured Nord’s packages and how they’re interconnected.
One of the recent major changes in Nord is that we’ve re-designed the underlying package architecture. The reason why we decided to do such a big fundamental change this close to our official release, is that we felt like the original structure was too complex to use and that there were too many dependencies between the different packages overall.
In early January we decided to do something about this and simplify the architecture. Originally, if you wanted to utilize any of the components, you had to first install and link our [Design Tokens](https://nordhealth.design/tokens/), then install and link [Webfonts](https://nordhealth.design/docs/developer/webfonts/), then our [CSS Framework](https://nordhealth.design/docs/developer/css-framework/), [Themes](https://nordhealth.design/design/themes/), and finally the [Web Components](https://nordhealth.design/components/) themself. That’s quite a few steps, huh?!
**In the re-designed architecture we have two different levels to the packages:**
1. On the first level, we have packages called [Webfonts](https://nordhealth.design/docs/developer/webfonts/), [Design Tokens](https://nordhealth.design/tokens/), and [Nordicons](https://nordhealth.design/icons/) (illustrated below). These packages are like atoms of the systems as they don’t have external or internal dependencies into any other packages in the system.
2. On the second level, we have [CSS Framework](https://nordhealth.design/docs/developer/css-framework/), [Web Components](https://nordhealth.design/components/), and [Themes](https://nordhealth.design/design/themes/) (illustrated below). These packages internally depend on the first level packages, but we wanted to hide these dependencies for the end user, Frontend Developer in this case, meaning that you’d more or less always install one or more of the second level packages only into your app to consume parts of the system:

As an example, if you would like to use our **CSS Framework,** you would only install that specific NPM package and that’s really it. You don’t have to care, as a user, that internally this package also also uses our **Webfonts** and **Design Token** packages:

Another example could be that if you’d want to skin your application with one of our themes, you’d also add the **Themes** package and choose a theme to use from it. Again, internally, we still use both **Webfonts** and **Design Token** packages, but as a user, you don’t have to care about those:

Finally, in the below example, we show all three first level packages being used internally (Webfonts, Design Tokens and Nordicons), but for the end user, only **CSS Framework** and **Web Components** will be relevant in this case:

You could also directly utilize one of the first level packages, like the **Design Tokens** if you’re working on a native iOS application and want to pull in the base colors and similar styles in XML format:

While the above is still possible, we wanted to avoid the user having to install a lot of different dependencies to be able to use a utility class from the CSS Framework, or a component from the Web Components package.
All of this seems quite evident in hindsight, but our original thinking was to strive for modularity to reduce the complexity and improve our system’s reusability by breaking it into small, easier to consume parts.
This modularity eventually increased the complexity for the users because we didn’t consider the API carefully enough, especially when it comes to CSS Custom Properties and the complex theming system we’ve got.
In the new architecture we’ve still kept the same level of modularity inside the system, but simplified it for our users and now offer a better and simpler API. These changes also nicely align with one of our key [design principles](https://nordhealth.design/design/foundations/principles/) which states that **“developers should be able to start using our tools in minutes, not hours, days or weeks.”**
Until the next time!
— Ariel
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Redesigning Nordicons Icon Library
Brand Designer Ilkka Janatuinen has been drawing on computers since the 1980s and is now designing brands, drawing UI and tweaking the tiniest design details at [H23 Agency](https://www.instagram.com/h23agency/). Ilkka Helped Nordhealth to redesign the Nordicons icon library in 2022.
A good, well executed set of icons is one of the cornerstones of [brand visuals](https://nordhealth.design/design/foundations/brand/) among other elements like the logo, typography and colors. It serves the functional purpose of making the application more intuitive to use, but there’s also the aesthetic part of being pleasing to look at and fit the rest of the brand visually.
Late last year, we started discussing about updating the [icon library](https://nordhealth.design/icons/) to better serve its purpose. Some of the icons were slightly outdated, or needed a redesign for functional reasons. We also had some challenges with the icon library’s license which wasn’t suitable for our needs. Our conclusion was that the easiest way to solve these problems would be to design a new icon library.
As we weren’t anymore limited by the previous [icon library’s](https://nordhealth.design/icons/) design, we first ran a few workshops to define a new icon style and sizing. We went through different options and tested them in all possible use cases. Designing for healthcare domain also meant that we had to keep in mind older low DPI screens, so not completely forgetting the rules of pixel perfect design either.
One of the key ingredients we wanted to concentrate on throughout the process, was to keep the designs as unambiguous as possible. We did this to be able to more effortlessly assist people to design more Nordicons with very [clear guidelines](https://nordhealth.design/design/foundations/iconography/).
My drawing tool of choice was Adobe Illustrator. I’ve used it for years and have set up the system to draw large sets of icons quickly. We tested the icons first in Figma, using the [Nord Design System’s components](https://nordhealth.design/components/) available in our [Figma Toolkit](https://nordhealth.design/design/foundations/figma/).

First, we defined the general icon style. We had already made the decision to keep the line icon style, as it’s a clear and versatile, so we started by trying different corner radiuses and line end variations.

There was quite a bit of testing done in this phase, as we were looking for the perfect sizes and dimensions for the icons. The aim was to design icons that would work well in different sizes and screen resolutions.
We tested mainly 10x10, 12x12, 20x20 and 24x24 pixel grids. Even 11x11 at one point, but in the end we settled on 10x10 as it seemed to look the best next to Inter typeface used throughout the design system.
I personally prefer 12px icon size that scales up to 24/36/48px and stays pixel perfect all the way, but as [Nord Design System](https://nordhealth.design) has much bigger variety of sizes, it didn’t seem like an ideal solution in this case.
We needed something more universal and keeping the icons plain and cohorent in a 10px grid seemed to work the best for our purpose. If we can’t fit all we need into that grid, then we shouldn’t have an icon for that purpose. To solve a design problem, keeping things simple seems to work most of the time.

At one point, we also explored an idea to draw three or four different sizes for most of the icons, but that was soon discarded.

As the icon styles and dimensions were agreed on, it was time to start drawing all the icons. We had a couple of meetings along the way and had a half day workshop in [Nordhealth Helsinki office](https://nordhealth.com){rel=""nofollow""} to make the final decisions on the designs.

The end result is a great, versatile set of icons and a well tested way to design new icons in the future. You can have a closer look of the whole icon library here: {rel=""nofollow""}
## TL;DR
- This redesign moves our icon style closer to the [Nordhealth brand](https://nordhealth.design/design/foundations/brand/). All icons now closely follow the brand guidelines and have strong affiliation with our logomark and design language.
- With this update we’re overcoming issues with the old icon style which was somewhat limiting our creativity and possibilities.
- This update allows us to get rid of licensing issues with the previous iconset as it prevented us from sharing any of our work in Figma community or GitHub.
Until the next time!
— Ilkka
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Interview with Design System Guide
# Rewriting Nord Docs with Nuxt
\*We've completely rewritten the Nord Design System documentation site from the ground up, replacing the previous Eleventy-based static site with a modern Nuxt 4 application.\*
## Why the rewrite?
The original documentation site served us well, but as Nord Design System grew, we needed a platform that could keep up with our ambitions. The Eleventy setup was becoming increasingly difficult to extend with interactive features, and we wanted to unlock new capabilities that a Vue-based framework could offer.
Key motivations included:
- **Nuxt Studio integration** — enabling designers and content editors to contribute directly to the docs without touching code.
- **Vue component ecosystem** — leveraging Vue's component model for richer, more interactive documentation pages.
- **AI support** — laying the groundwork for AI-assisted tooling and integrations.
- **Better developer experience** — hot module replacement, TypeScript throughout, and a more maintainable codebase.
## What's new
### Built on Nuxt 4 with Content v3
The new docs site uses [Nuxt 4](https://nuxt.com){rel=""nofollow""} with [@nuxt/content v3](https://content.nuxt.com){rel=""nofollow""} for content management. All existing markdown content was migrated, and we've added custom MDC (Markdown Components) for interactive elements like callouts, component usage blocks, and live examples.
### Full-text search
We've implemented client-side full-text search powered by [MiniSearch](https://lucaong.github.io/minisearch/){rel=""nofollow""}, allowing you to quickly find components, guidelines, tokens, and documentation pages.
### Component documentation from source
Component pages are now generated directly from the web component source code using `nuxt-component-meta`. Properties, events, slots, methods, and CSS custom properties are extracted automatically, ensuring the docs always match the latest release.
### Live examples in iframes
Every component example runs in its own isolated iframe, providing a clean rendering environment that accurately represents how components behave in production. Examples are prerendered as part of the build for fast loading.
### LLMs.txt support
We've added `/llms.txt` and `/llms-full.txt` routes that provide AI-friendly versions of our documentation, making it easier for large language models to understand and reference Nord Design System.
### Sitemap, SEO and accessibility
The site includes automatic sitemap generation, structured data with Schema.org, and comprehensive meta tags. We've maintained our commitment to accessibility throughout the rebuild.
### Theme Builder and Color Generator
The [Theme Builder](https://nordhealth.design/theme-builder) and [Color Generator](https://nordhealth.design/color-generator) tools have been rebuilt as Vue pages, with full theme switching support and URL-based state persistence.
## Technical highlights
- **Nuxt 4** with Vue 3.5 and Vite
- **@nuxt/content v3** with SQLite-backed content queries
- **Tailwind CSS v4** with the Nord CSS utility layer
- **Shiki** for syntax highlighting with Nord-themed code blocks
- **Server API routes** for component metadata, examples, navigation, and assets
- **Static generation** with nearly 2,000 prerendered routes
- **GitHub Pages** deployment with PR preview support
## What's next
This rewrite opens the door for several exciting improvements we have planned:
- **Nuxt Studio** for visual content editing
- **Vue web component** experiments
- **Interactive playground** with Storybook for trying components in the browser
- **AI skills** for integrating Nord Design System with AI-assisted development workflows
- **MCP server** for connecting Nord Design System directly to AI-powered development tools
We're excited about the foundation this provides and look forward to building on it.
# Latest Updates
\*Stay up to date with the latest blog posts, announcements, and insights from the Nord Design System team.\*
\- \[Explore and Create Themes for Your Team]\(/updates/october-2026-themes) — Joseph Anson, 2026-10-15
\- \[Four Alpha Component Families for Product Interfaces]\(/updates/july-2026-alpha-components) — Joseph Anson and João Gonçalves, 2026-07-29
\- \[18 New Components, 56 Component Parts, and a Redesigned Docs Website]\(/updates/july-2026-component-updates) — Joseph Anson and João Gonçalves, 2026-07-06
\- \[Introducing Storybook and the New Playground Experience]\(/updates/march-2026-storybook-playground) — Joseph Anson, 2026-03-05
\- \[Rewriting Nord Docs with Nuxt]\(/updates/february-2026-nuxt-docs-rewrite) — Joseph Anson, 2026-02-11
\- \[Introducing Brands for Nord Design System]\(https\://arielsalminen.com/2025/introducing-brands-for-nord-design-system/) — Ariel Salminen, 2025-06-04
\- \[Interview with Design System Guide]\(https\://thedesignsystem.guide/interview-ariel-salminen) — Ariel Salminen, 2024-02-21
\- \[Finalist for the Best Design System Award]\(/updates/may-2023-jammies-nomination-copy) — Ariel Salminen, 2023-05-22
\- \[Redesigning Nordicons Icon Library]\(/updates/february-2023-redesigning-nordicons-icon-library) — Ilkka Janatuinen, 2023-02-24
\- \[Finalist for the Jamstack Conf Jammies]\(/updates/october-2022-jammies-nomination) — Ariel Salminen, 2022-10-25
\- \[How we use Custom Properties in Web Components]\(https\://web.dev/custom-properties-web-components/) — David Darnes, 2022-08-17
\- \[Tabs components]\(https\://darn.es/building-tabs-in-web-components/) — David Darnes, 2022-06-29
\- \[Launching Nord Design System]\(https\://arielsalminen.com/2022/launching-nord-design-system/) — Ariel Salminen, 2022-04-05
\- \[Statistics for the first year]\(/updates/march-2022-statistics-for-the-first-year) — Ariel Salminen, 2022-03-31
\- \[Nord Design System architecture]\(/updates/february-2022-design-system-architecture) — Ariel Salminen, 2022-02-21
\- \[How we use Figma]\(/updates/january-2022) — Eric Habich, 2022-01-31
\- \[December, 2021]\(/updates/december-2021) — David Darnes, 2021-12-20
\- \[October, 2021]\(/updates/october-2021) — Ariel Salminen, 2021-10-14
\- \[September, 2021]\(/updates/september-2021) — Ariel Salminen, 2021-09-07
\- \[June, 2021]\(/updates/june-2021) — Ariel Salminen, 2021-06-30
\- \[May, 2021]\(/updates/may-2021) — Ariel Salminen, 2021-05-16
\- \[February, 2021]\(/updates/february-2021) — Ariel Salminen, 2021-02-17
\- \[Latest Updates]\(/updates) — null, null
# How we use Figma
You’re reading the seventh Nord Design System monthly update. This month we’ve worked on improving the system’s architecture, added new components and worked on refining Nord Figma Toolkit.
Nord’s [Figma Toolkit](https://nordhealth.design/design/foundations/figma/) is a resource for exploration and collaboration. It contains the building blocks for designing with Nord. Our goal is to create a toolkit that anyone at [Nordhealth](https://nordhealth.com){rel=""nofollow""} can use to prototype ideas. The toolkit is in progress at the moment, but will launch by the end of March. We’ve gathered some generic guidelines we follow below:
## Base components for variant sets
Components can contain many variations or repeating elements. It's not uncommon to have 100+ variations of an input for example. Imagine realizing that you misaligned a text box and updating each one by hand.

By making changes to a base component instead of each instance, we can make an adjustment once and it will update across all of our variants.
\*\[Video: /img/updates/figma/2.mp4]\*
When exporting a component to the team library, we hide the base components since they wont be needed. You can do this by going to the Assets Panel in the source Figma file, right-clicking, and selecting Hide when publishing.

## Consistency with styles
In [Figma](https://www.figma.com/){rel=""nofollow""}, Styles are a lot like Components. Styles allow you to define properties such as colors, font, and box shadows. If you want to update a color for example, you can modify the Color Style and it will automatically update wherever that Color Style is used.
\*\[Video: /img/updates/figma/4.mp4]\*
An additional benefit of using Styles is that they can be applied to theming directly in Figma. In our library we theme by using the slash naming convention `Nord Light / Accent` and the plugin [Themer](https://www.figma.com/community/plugin/731176732337510831/Themer){rel=""nofollow""}.
Nord uses [Design Tokens](https://nordhealth.design/tokens/) to store variables for the elements of our design system. These tokens store values for [Color](https://nordhealth.design/tokens/#color){rel=""nofollow""}, [Font](https://nordhealth.design/tokens/#font-size){rel=""nofollow""}, [Box Shadow](https://nordhealth.design/tokens/#box-shadow){rel=""nofollow""}, and many other base styles. In the [Nord Figma Toolkit](https://nordhealth.design/figma/){rel=""nofollow""}, we use these tokens when defining our Styles to ensure consistency across platforms.
\*\[Video: /img/updates/figma/5.mp4]\*
## Components that are effortless to play with
A design system should provide flexible components to designers that are effortless to manipulate and update with new content. If a component breaks when a designer applies it their use case, then two things might happen. They may either unlink it from the Team Library or create a custom component. We'd like to avoid both of those cases. By creating variant sets with Auto-Layout and Constraints we can make updates easier, and save designer’s time. It's also useful for communicating reflow behavior to developers.
At a basic level we've created components like buttons that automatically resize when you update the contents. You can also stretch this component to create full-width buttons when needed.
\*\[Video: /img/updates/figma/6.mp4]\*
By using auto-layout in content blocks, we can make it easier to maintain the correct spacing and layout. You can resize and update content without having to revisit the documentation.
\*\[Video: /img/updates/figma/7.mp4]\*
We also support complex behavior in larger components such as our table. Here we've allowed for horizontal and vertical resizing, 3 content density settings, fixed-width or fill-width cell resizing, desktop and mobile versions, as well as 8 content types for table cells and headers.
\*\[Video: /img/updates/figma/8.mp4]\*
## In context components
The Components of Nord are primarily base level Components. In order to show how Components can be used and how they form larger patterns we’ve created Component Groups and [Interface Templates](https://www.figma.com/file/iGUx4IYLFa8jPHM0VIGOGW/?node-id=2%3A9){rel=""nofollow""}.
Component Groups might include patterns such as a Radio Button Group. Radio buttons are always grouped together, so we've added this group to the library to make it simpler to create a form.

Interface templates show how Nord can be used to compose an entire page or application.

## Curating the library
We've curated the Nord library to make design approachable to anyone at Nordhealth. We keep everything in one library for the sake of simplicity.
### 1. Hide base components
By hiding base components and atoms for each component, we only surface complete components in the library. For example, we wouldn't want the base component for a form input to show in our library. We only surface the final form component which contains the component variants such as hover, active, input, and error states.
### 2. Use variant sets to provide components
Variants allow us to consolidate states into a single component. The button component for example contains 1334 variants, which would be overwhelming to show in the Nord Figma Library. Instead, we surface a single dynamic button component using variants.
### 3. Applying an approachable naming convention
Figma defines component names in a library based on Page name, Frame name, then Component name in that order. In order to keep the library easier to understand we removed frames from the structure and use the naming convention `Page name > Component name`. We typically house 1-5 components per page so a 2 level navigation structure will work best at the moment.
\*\[Video: /img/updates/figma/11.mp4]\*
## Making it approachable
There are a few things we can do to make our Figma Library approachable.
### 1. Add a cover photo
This is a quick change and makes the Nord Design System file approachable. When you're looking at a sea of draft files, the Nord Library is easier to find. If you'd like to add a cover photo to your design file you can [follow the instructions from Figma](https://resources/support/.figma.com/hc/en-us/articles/360038511413-Set-custom-thumbnails-for-files){rel=""nofollow""}. You can also use our [File Thumbnail](https://www.figma.com/file/u32okMUqi5BlWsG2k1JZgH/Nord-Design-System?node-id=2265%3A133092){rel=""nofollow""} as a template to create your own.
### 2. Create a sticker sheet of components
In the Nord Design File we've organized a scannable sticker sheet of components. You can also copy and paste a component from the sticker sheets in the [Nord Design System Figma File](https://www.figma.com/file/u32okMUqi5BlWsG2k1JZgH/Nord-Design-System?node-id=1645%3A129904){rel=""nofollow""}. Personally, I prefer this workflow over using the Assets panel in Figma. Each component has clear sections for the component, variants, and building blocks which we call atoms.
### 3. Create approachable component pages
We've categorised our components using pages in Figma. We combine the names with emojis to make them easier to scan.
\*\[Video: /img/updates/figma/12.mp4]\*
## Create link between Figma and docs
With design systems in general, we want to centralize as much as possible. When it comes to documentation our approach is for documentation to exist on [nordhealth.design](https://nordhealth.design/){rel=""nofollow""} and not in Figma. There are two ways we can create links between Figma and the Nord documentation.
Add a View documentation link in the header of each component. You can create links to a url directly in figma by highlighting the text you want to link, type `Cmd+K`, enter your url and then hit `return`.
If you're using a Nord component in your own design file, you can also link to documentation from Figma. Selelct a component and open the inspect panel. Click the View documentation button and you'll be redirected to the component page on nordhealth.design.
\*\[Video: /img/updates/figma/13.mp4]\*
Until the next time!
— Eric
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Four Alpha Component Families for Product Interfaces
\*Nord 5.1 introduces four alpha component families for the product interfaces teams build most often: compact input compositions, constrained rows, split views and locale-aware dates.\*
The release is deliberately marked alpha. These components are ready for early product adoption and feedback, but their APIs may evolve as teams use them in production-shaped interfaces. Existing stable components keep their current APIs.
## Compose denser controls
[Input Group](https://nordhealth.design/components/input-group/) composes controls with add-ons and shared sizing, making compact search, currency, and inline-action fields easier to build consistently.
\*See usage example\*
[Overflow List](https://nordhealth.design/components/overflow-list/) keeps a constrained row useful by moving excess items into an accessible menu instead of letting the layout wrap or clip unpredictably.
\*See usage example\*
## Adapt layouts without local one-off patterns
[Resizable](https://nordhealth.design/components/resizable/) provides keyboard-accessible, composable resize handles and panels for split views.
\*See usage example\*
[Timestamp](https://nordhealth.design/components/timestamp/) presents dates and times with locale-aware formatting and clear semantic markup.
\*See usage example\*
## Try alpha components deliberately
Start with a bounded screen or feature where your team can give feedback quickly. Keep the component imports explicit, follow the composition examples in each component page, and retain visual-regression coverage around the states that matter to your product. We will use that feedback to stabilize APIs before these families graduate from alpha.
For exact version details, see the [Web Components changelog](https://nordhealth.design/changelogs/).
# 18 New Components, 56 Component Parts, and a Redesigned Docs Website
\*The July 2026 Nord release pairs a redesigned documentation website with Nord 5 component releases. The new docs make the system easier to browse, preview, test and copy from, while the component library adds new patterns across forms, filters, data display, navigation, containers and layout.\*

This release brings together two related pieces of work. The first is a redesigned documentation website that feels closer to the products built with Nord: persistent navigation, clear category browsing, full-site light and dark mode, a command-style search entry point, live component previews and quick template previews. The second is the component release itself, with new Light DOM components, refreshed guidance and Storybook-backed examples across the library.
For package-level release notes and exact version history, see the [Web Components changelog](https://nordhealth.design/changelogs/). This article focuses on what changed from a product and documentation point of view.
At a glance:
- The docs website has a new application-style shell with persistent navigation, search, page outlines and light/dark mode throughout.
- The [Components overview](https://nordhealth.design/components/) is now grouped by purpose, matching the way teams look for UI building blocks.
- Component pages combine guidance, Storybook-backed examples, accessibility notes and generated API reference.
- The new [Blocks](https://nordhealth.design/blocks/) gallery provides copy-paste product patterns built from Nord components.
- The new [Templates](https://nordhealth.design/templates/) gallery lets teams quickly preview full-page layouts, copy their markup, or open them full screen.
- Nord 5 adds **18 new components** made up of **56 individual component parts**, plus updates to existing components, across the same groups used on the Components overview.
## New website design
The new website is built around the way teams actually use a design system. Instead of treating the docs as a set of isolated reference pages, the redesigned site brings navigation, examples, status, search and release context into the same workspace.
The homepage now opens with a live product surface built from Nord components. It shows the design language in context before asking people to choose a package or read an API table. The release banner at the top points directly to the latest component work, so teams can discover what changed without digging through changelogs first.
The site shell also gives the docs more room to grow:
- **Persistent sidebar navigation** keeps components, design tokens, Tailwind CSS, blocks, templates, icons and updates close at hand.
- **Light and dark mode throughout** lets teams review documentation, components, blocks and templates in the same appearance modes their products support.
- **Search entry points** are always visible, with keyboard hints for people who move quickly through the docs.
- **Right-side outlines** make long component pages easier to scan, especially pages with examples, accessibility notes and generated API sections.
- **Status badges** show when a component is new, alpha, beta, deprecated, Light DOM based, or updated.
The goal is not only to make the website look newer. It is to make the documentation behave more like a working tool for product teams.
## Browsing components by purpose

The [Components overview](https://nordhealth.design/components/) now groups the library by the same categories used across the site:
- Action
- Data input
- List & table
- Content & media
- Feedback & status
- Navigation
- Overlay
- Layout
- Container
This makes the overview easier to scan than one long alphabetical list. You can still filter by name from the header, but the default view answers a more useful question: "What kind of UI am I trying to build?"
Each card pairs a component illustration with a short description and release status. New components are visible at a glance, deprecated components stay discoverable without being promoted, and Light DOM components are clearly marked. The sidebar also mirrors the component list, so people can jump directly into a component page without losing the larger category context.
## Richer component pages

Component pages are now designed to teach usage before exposing the complete API reference. The top of a page gives the component description, status badges and a Storybook-backed example. From there, the page moves through usage guidance, composition notes, examples, accessibility guidance and generated API sections.
The embedded example viewer is the biggest shift. Instead of static screenshots or isolated snippets, examples now run as live stories with controls, code and accessibility tabs. This lets people test the component state before copying an implementation detail.
The page structure is consistent across new and existing components:
- **Usage guidance** explains when to reach for the component and how it fits with nearby patterns.
- **Composition sections** show how compound components and parts work together.
- **Examples** use Storybook stories, so the same source supports docs, testing and the standalone Storybook.
- **Accessibility notes** call out labeling, keyboard behavior and screen reader expectations.
- **Generated API reference** documents props, slots, methods, events, CSS custom properties, state attributes and dependencies from source metadata.

Compound components benefit the most from this format. Accordion, Field, Combobox and Pagination all rely on composition. The docs can now explain the model in prose, show a working example, and keep the generated API for the parent and parts on the same page.
## Component model
The new components also establish the direction for future Nord APIs. They are designed to be easier to compose in product code and easier to document from source.
- **Light DOM rendering for new components** lets application CSS, `@nordhealth/css` utilities and global styles reach component internals without `::part`. Existing Shadow DOM components are unchanged.
- **Composition-first APIs** split larger patterns into small parts that can be assembled to match the interface anatomy. Field, Item, Pagination, Accordion and Combobox are all examples of this approach.
- **Shared behavior controllers** keep focus management, open state, disabled state, transitions, roving focus and active descendant behavior consistent across component families.
This is why the release is bigger than a set of isolated tags. It gives product teams a more consistent way to build forms, filters, disclosure patterns, lists and navigation while keeping each part inspectable in the docs.
## Component releases
Nord 5 is a broad component release, but the changes are not all the same kind of change. Some are brand new components, some are new component families, and others are updates to existing components so they work better with the new model.
The release follows the same grouping as the [Components overview](https://nordhealth.design/components/).
### Action
Action components do not get a new standalone primitive in this release, but the redesigned docs make action patterns easier to evaluate. Button, Button Group, Command Menu, Message and Segmented Control now appear in the grouped overview with clearer illustrations and status context.
This also matters for blocks and templates, where action components usually appear as part of a larger workflow rather than as isolated examples.
### Data input
Data input is the largest part of this release. It includes new form structure, richer picker controls and a complete filter family.
- [Field](https://nordhealth.design/components/field/), Field Group and Field Set provide composable form layout and labeling primitives.
- Existing form controls still work standalone, but can now be wrapped in Field when you need shared label, hint, error and required behavior.
- [Combobox](https://nordhealth.design/components/combobox/) and [Autocomplete](https://nordhealth.design/components/autocomplete/) add virtualized option lists, declarative options and groups, async patterns, clear buttons, slots, auto-highlight behavior, disabled items and creatable entries.
- [Number Field](https://nordhealth.design/components/number-field/) adds formatted numeric input with parsing and formatting callbacks, currency and unit slots, and wheel and scrub interactions.
- [OTP Field](https://nordhealth.design/components/otp-field/) adds grouped one-time-code input with normalization, masking, form integration and right-to-left support.
- [Date Range Picker](https://nordhealth.design/components/date-range-picker/) adds a two-month range calendar, presets, inline mode, custom triggers, responsive single-month collapse, read-only styling and disabled/highlighted date callbacks.
- [Filter Dropdown](https://nordhealth.design/components/filter-dropdown/) adds a chip trigger with selectable options, search, groups, tree selection, select-all, clearable and loading states.
- [Filter Date Range](https://nordhealth.design/components/filter-date-range/) brings the date-range picker pattern into the filter family.
- [Calendar](https://nordhealth.design/components/calendar/) now supports native range selection, hover previews, multi-month display and date disabling/highlighting callbacks.
- [Time Picker](https://nordhealth.design/components/time-picker/) is a new native time field paired with a dropdown of selectable times at a configurable interval, with `round-to-interval` and `hour-format`.
- [Fieldset](https://nordhealth.design/components/fieldset/) is deprecated in favor of the new Field family.
\*See usage example\*
\*See usage example\*
### List & table
[Item](https://nordhealth.design/components/item/) adds a composable row primitive for people, files, settings and other single pieces of content. It is useful anywhere a product surface needs a repeated row with leading media, primary content, metadata and trailing actions.
Item is intentionally small. It gives teams a consistent row anatomy without forcing every list or table-like surface into the same full table component.
### Content & media
[Kbd](https://nordhealth.design/components/kbd/) and Kbd Group add styled keyboard key and shortcut display. They are useful in docs, command menus, keyboard shortcut references and power-user workflows.
The new docs use keyboard hints in navigation and search, so these components also help document Nord itself with Nord components.
[Truncate](https://nordhealth.design/components/truncate/) adds a primitive for shortening overflowing text with an accessible full-text fallback, useful in tables, cards and dense list rows where space is limited.
### Feedback & status
[Meter](https://nordhealth.design/components/meter/) adds a static measurement display for values such as usage, battery, capacity or score. It gives teams a lighter-weight choice when they need to communicate a bounded value without implying task progress.
Existing feedback components also received updates:
- [Banner](https://nordhealth.design/components/banner/) adds an `actions` slot for trailing calls to action or dismiss buttons.
- [Toast](https://nordhealth.design/components/toast/) groups render in the browser top layer above modals.
These changes make feedback patterns work better in complex application shells, where overlays, navigation and messages often appear at the same time.
### Navigation
Navigation gains both new components and visual refinements.
- [Outline](https://nordhealth.design/components/outline/) adds an in-page table of contents with controlled and scroll-spy modes.
- [Pagination](https://nordhealth.design/components/pagination/) adds a composed pagination model with loading, numbered, simple, icon-only, cursor and right-to-left examples.
- [Tab Group](https://nordhealth.design/components/tab-group/) now pre-selects the first asynchronously slotted tab in framework rendering.
- Navigation receives refreshed selected, active and hover treatments.
\*See usage example\*
\*See usage example\*
### Overlay
Overlay components received updates that make them more predictable in composed product surfaces.
- [Popout](https://nordhealth.design/components/popout/) adds opt-in controlled mode.
- [Tooltip](https://nordhealth.design/components/tooltip/) stays in the top layer until its fade-out transition ends, preventing flashes behind layout navigation.
These changes are small from an API point of view, but important for reliability. Popouts and tooltips often sit inside dense tables, filters, modals and navigation shells, where layering bugs are especially visible.
### Layout
Layout updates focus on application shell behavior and scrollable surfaces.
- [Scroll Area](https://nordhealth.design/components/scroll-area/) is a new scroll container with custom, consistently-styled scrollbars, optional edge fades and `always-show-scrollbar`.
- [Aside](https://nordhealth.design/components/aside/) and Aside Trigger add a new right-side rail and drawer layout for surfacing secondary content alongside the main view.
- [Layout](https://nordhealth.design/components/layout/) aligns sticky footers to the live navigation width instead of a hardcoded size.
- Layout, Aside and Aside Trigger receive refreshed selected, active, hover and surface treatments.
The visual updates are most noticeable in larger screens where side navigation, content, headers and sticky footers need to feel like one coherent application frame.
### Container
Container components add new ways to group and reveal content.
- [Accordion](https://nordhealth.design/components/accordion/) adds stacked sections with single- or multi-open behavior.
- [Collapsible](https://nordhealth.design/components/collapsible/) adds a focused show/hide primitive for a single region.
\*See usage example\*
Accordion is for related sets of sections. Collapsible is for one disclosure region. Having both keeps common disclosure patterns consistent without forcing teams to use a larger component than the interface needs.
## Blocks and templates

The new [Blocks](https://nordhealth.design/blocks/) page shows copy-paste UI sections built from Nord components. Blocks sit between a single component and a full application template: they are small enough to reuse directly, but large enough to show how components work together in real product surfaces.
The first batch includes dashboard, scheduling, consultation, communication, patient and client, billing, form, onboarding, authentication and layout patterns. They are especially useful when you know the product pattern you need but do not want to start from a blank page.
Blocks are also a practical way to test component combinations. A component can look correct in isolation but still need adjustments once it appears beside filters, cards, tabs, actions, tables and empty states. The blocks gallery gives us a shared place to document those product-level combinations.

The [Templates](https://nordhealth.design/templates/) gallery takes the next step up from blocks. Templates are complete page layouts built from Nord components, grouped by use case such as application, dashboard, layout, login, navigation, settings and theming.
The important improvement is speed: you can browse the gallery, open a template in place, preview the live page, copy its markup, or view it full screen without leaving the flow. That makes templates useful both for starting a new screen and for quickly checking how components behave together in a realistic page shell.
## What to try first
If you are reviewing the release, start with these areas:
1. Open the [Components overview](https://nordhealth.design/components/) and scan the new category groups.
2. Try the [Date Range Picker](https://nordhealth.design/components/date-range-picker/), [Combobox](https://nordhealth.design/components/combobox/) and [Accordion](https://nordhealth.design/components/accordion/) pages to see the new docs format.
3. Toggle between light and dark mode while reviewing components, blocks and templates.
4. Open the [Blocks gallery](https://nordhealth.design/blocks/) and copy one pattern into a local prototype.
5. Open the [Templates gallery](https://nordhealth.design/templates/) to quickly preview full-page layouts and view one full screen.
6. Check your visual-regression baselines around navigation, layout, overlays, feedback and form controls.
7. Read the [Web Components changelog](https://nordhealth.design/changelogs/) for exact package versions and release details.
## What's next
This release is a foundation, not a finish line. A few areas we are actively working on:
- **Graduating the alpha components.** Several of the new components — Combobox, Autocomplete, Date Range Picker, Meter, Number Field, OTP Field, Time Picker and others — ship as alpha while we finalise their APIs. Expect those interfaces to settle and the alpha labels to drop as we gather feedback from real product use. If you are adopting them now, tell us where the API feels awkward.
- **More blocks and templates.** The first batch covers common product surfaces, but it is deliberately a starting point. We will keep adding patterns — and refining existing ones — as we see which combinations teams reach for most.
- **Deeper composition.** The composition-first direction behind Field, Accordion and Item continues. Next up, we plan to move **Card**, **Modal** and **Dialog** to the same small, slot-driven parts that compose cleanly rather than one-off wrappers, so there is less repeated product code to maintain.
- **More components.** We are exploring several new components, including **Overflow List**, **Input Group**, **Timestamp** and **Resizable**.
- **Framework-agnostic foundations.** We are exploring headless primitives so the same accessible behaviour can be shared beyond web components, making Nord easier to adopt across React, Vue and other stacks.
We will share specifics as they land — follow the [Web Components changelog](https://nordhealth.design/changelogs/) and [Latest Updates](https://nordhealth.design/updates/) for the next steps.
## Upgrade notes
Existing component APIs are intended to remain compatible, so most applications do not need a code migration just to install Nord 5. The visual system has changed in places, especially around navigation, surfaces and newly documented component states, so visual-regression baselines should be regenerated after upgrading.
The most important adoption work is deciding where the new composition-first components should replace local patterns. Field, Combobox, Date Range Picker, Accordion, Pagination and Item are all designed to reduce repeated product code, but they are best introduced deliberately where they simplify real screens.
For exhaustive package notes and release dates, read the [Web Components changelog](https://nordhealth.design/changelogs/).
# June, 2021
You’re reading the third Nord Design System monthly update. This month we’ve been focusing on onboarding new team members and also rolling out the new brand guidelines into the documentation.
In the beginning of the month, [Eric Habich](https://www.linkedin.com/in/eric-habich-236484ab/){rel=""nofollow""}, our new product designer, joined Nord Design System team. I’ve personally worked with Eric in the past with various clients when I was still living in the San Francisco Bay Area and knew beforehand how talented addition he’d be for our small team. As the first task to get more familiar with Nord, Eric illustrated [our home page](https://nordhealth.design) and the different tools we offer with these nifty drawings:
[{style="max-width:738px"}](https://nordhealth.design)
The interesting bit with these illustrations is that they’re all themed with CSS Custom Properties and use Nord’s [theming feature](https://nordhealth.design/design/themes/). This means that each illustration variant in the documentation is actually the same SVG which gets its colors from the [design tokens](https://nordhealth.design/tokens/).
In late May, we also published [Nordhealth brand guidelines](https://nordhealth.design/design/foundations/brand/). This is a result of the brand work we’ve been working on since February and which I shared a little about in the [last monthly update](https://nordhealth.design/updates/may-2021/):
[{loading="lazy"}](https://nordhealth.design/design/foundations/brand/)
Together with the above update, we’ve been also improving our [downloads section](https://nordhealth.design/design/assets/) throughout the month to make sure all the brand assets would be available there for downloading and usage:
[{loading="lazy"}](https://nordhealth.design/design/assets/)
Later during June, we started moving our focus more into product design and started doing both background research and competitive research to help us start designing the system’s parts. We currently have various related Figma documents under the Nord project, like for example the below Interface Audit:
{loading="lazy"}
…or this document where we’ve started collecting user flows, screens, and information architectures…
{loading="lazy"}
…or this document with typeface tests and visual directions to work with…
{loading="lazy"}
…and eventually also documents where we’ve started to draft out the actual interface concepts:
{loading="lazy"}
Finally, while we’ve moved things forward in Figma, we’ve also started researching on how to sync Figma, our different [color themes](https://nordhealth.design/design/themes/), and the code based [design tokens](https://nordhealth.design/tokens/) and built this prototype Figma plugin that fetches the tokens from Nord Design Tokens Node.js package and generates color libraries for Figma usage and syncing:
{loading="lazy" style="max-width:579px"}
June has been busy, and there’re quite a few things under work behind the scenes which aren’t yet visible in the live system, but which will later start surfacing here in the form of components and larger user interface patterns. Right now though, as it is the end of the month, our whole team would like to wish you all wonderful summer holidays! We’ll catch up again with you in August.
Until the next time!
— Ariel
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Tabs components
# Introducing Brands for Nord Design System
# Statistics for the first year
You’re reading the ninth Nord Design System monthly update. During the past month we’ve been preparing the system for official launch and making sure we offer stable API and comprehensive docs.
Looking back in time, we started our design system journey at the end of 2020 with initial user research. We did this because we wanted to first better understand the challenges we’re trying to solve at [Nordhealth](https://nordhealth.com){rel=""nofollow""} and how the design system might help.
Back then, we interviewed around 60 different persons from different teams, with different backgrounds, and with different levels of experience. The result of this research was an organizational challenges heatmap that highlighted organization level problems.
Once we had this data, we continued the research with a [series of workshops](https://arielsalminen.com/2018/vue-design-system/#figuring-out-challenges){rel=""nofollow""}. These workshops were meant to reveal a lack of alignment and personal biases across teams. The final output from these workshops was a set of prioritized actions that directly informed the backlog of the design system.
Once we knew what the challenges were, it was a matter of creating fundamental [principles](https://nordhealth.design/design/foundations/principles/) and [goals for the system](https://nordhealth.design/resources/about/#our-goals) that we should follow to start solving these issues. The concrete design and development work on the design system started in August 2021 when Eric and Nick joined the team.
Now, 8 months later, we’re excited to launch Nord Design System and all of our tools for production usage! 🎉
---
## Tools you can use today
All of our tools are out of beta phase starting today and ready for production usage. [Web Components](https://nordhealth.design/components/) have also reached release candidate (RC) status and we’ll publish `1.0.0` next week unless significant bugs emerge.
You can read more about each tool below:
\*\*\[Figma Toolkit]\(/design/foundations/figma/)\*\* - nordhealth.design/figma/
\*\*\[Web Components]\(/components/)\*\* - nordhealth.design/components/
\*\*\[CSS Framework]\(/css/)\*\* - nordhealth.design/css/
\*\*\[Themes]\(/design/themes/)\*\* - nordhealth.design/themes/
\*\*\[Theme Builder]\(/theme-builder/)\*\* - nordhealth.design/theme-builder/
\*\*\[Nordicons]\(/icons/)\*\* - nordhealth.design/nordicons/
\*\*\[Design Tokens]\(/tokens/)\*\* - nordhealth.design/tokens/
\*\*\[Webfonts]\(/docs/developer/webfonts/)\*\* - nordhealth.design/webfonts/
We hope you enjoy using Nord’s tools and help us improve them by providing feedback to us via [Slack](https://nordhealth.design/resources/support/), [Office Hours](https://nordhealth.design/resources/support/), [Monthly Meetups](https://nordhealth.design/resources/support/), and also the feedback functionality found from the bottom of each documentation page.
Hope to hear from you soon!
---
## Statistics for the first year
We wanted to collect a few statistics here, so that we can better track the progress on Nord. We think some of these metrics are impressive for such a small team as for a long time the team was only one person, until we hired two more during summer 2021, and eventually by the end of the year the fourth person, [Dave](https://twitter.com/daviddarnes){rel=""nofollow""}.
**Here you go, the numbers:**
### Team has grown from 1 to 4
Nord team has grown from one to four persons and we’re [currently hiring](https://nordhealth.design/resources/careers/) two more designers and developers for the team.
\[View careers and apply]\(/resources/careers/)
---
### 109,431 lines of code written
We had three people write a total of 109,431 lines of code that form the foundations of Nord Design System today.

---
### 2,786 commits
We had three people make almost 3000 commits over the past year which are now merged to Main branch on [Nordhealth GitHub](https://github.com/nordhealth){rel=""nofollow""}.

---
### 1296 button variations and states
There are 1296 [button variations](https://nordhealth.design/components/button/) and states. This includes all [6 themes](https://nordhealth.design/design/themes/) we have, but you shouldn’t ever underestimate a button and what a seemingly simple component can cost to an organization when it’s being reinvented by every single product team.

---
### 3218 Figma frames
We’ve worked through 49 [Figma](https://nordhealth.design/design/foundations/figma/) files which contain a total of 107 pages and 3218 frames that we’ve used for background research, design exploration, prototyping, and the components themselves.

---
### 31 code based components
During the past 8 months we’ve designed and built a total of 31 code based Web Components. 27 of them [can be seen in the documentation](https://nordhealth.design/components/) already and 4 more are waiting behind existing pull requests on GitHub.
{style="max-width: 600px;"}
---
### 32.96 kB total bundle size
[Lit](https://lit.dev/){rel=""nofollow""} has helped us to keep Nord’s bundle size small. All of our CSS and [Web Components](https://nordhealth.design/components/) combined weigh around 33 kB (minified and compressed).
{style="max-width: 500px;"}
---
### 95.57 % code coverage
Our automated tests currently cover 95.57% of the code base. We use [Web Test Runner](https://modern-web.dev/docs/test-runner/overview/){rel=""nofollow""}, [Mocha](https://mochajs.org/){rel=""nofollow""}, and [Puppeteer](https://pptr.dev){rel=""nofollow""} to automate E2E, unit, accessibility, and screenshot diff tests.

---
### 256 design tokens
There are [256 design tokens](https://nordhealth.design/tokens/) that we use to store design variables like colors, font sizes and spacing information. These are used instead of hard coded values to ensure a better UI consistency across different platforms.
{style="max-width: 433px;"}
---
### 200,000+ page views
We have had over 200K page views on [nordhealth.design](https://nordhealth.design){rel=""nofollow""} documentation website since May, 2021 when we started measuring visits.

---
### 3373 hours of work
Our team of four persons has used a total of 3373 hours to design, build and maintain the system we have today.

---
### 282 versions published
During the past year we’ve published 282 packages versions to [npm](https://www.npmjs.com/org/nordhealth){rel=""nofollow""} that have recently started getting more downloads as teams start utilizing these tools.

---
### 402 pages of documentation
We’ve created over 400 pages of documentation and live code examples combined during the past year which are all live at [nordhealth.design](https://nordhealth.design){rel=""nofollow""}.
{style="max-width: 650px;"}
---
### 100% Lighthouse performance score
[Lighthouse](https://developer.chrome.com/blog/lighthouse-load-performance/){rel=""nofollow""}, a tool by Google that evaluates websites by their performance, accessibility, and other best practices, scores our application templates with 100% score.
{style="max-width: 650px;"}
---
### 309 completed Linear issues
We’ve worked through a backlog of 385 tasks and completed 309 of them in a tool called [Linear](https://linear.app/){rel=""nofollow""} that we use for issue tracking and task prioritization.
{style="max-width: 339px;"}
---
### 120 completed roadmap goals
We’ve completed 120 high level roadmap goals since we’ve started the work on Nord.
- ~~Bug reporting capabilities and enhanced support for design system.~~
- ~~Improved documentation regarding getting started with Nord.~~
- ~~Creating content guidelines for components.~~
- ~~Web Components reaches stable 1.0 state.~~
- ~~Badge component~~
- ~~Button component~~
- ~~Calendar component~~
- ~~Card component~~
- ~~Checkbox component~~
- ~~Etc…~~
Until the next time,
— Ariel
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Introducing Storybook and the New Playground Experience
\*Nord Design System now ships with Storybook 10, bringing a powerful new playground experience to every component page. Explore components interactively with controls, test across themes and viewports, run accessibility audits, and export to CodePen — all without leaving the docs.\*

## Why Storybook?
Our previous documentation examples were static HTML snippets rendered in iframes. They showed what a component looked like, but not how it behaved when you changed its properties, resized the viewport, or switched themes. Developers had to read the API docs separately and piece things together manually.
With Storybook, every component now has a living, interactive playground backed by the same source of truth as our component library. This means:
- **Instant feedback** — change a prop and see the result immediately.
- **Single source of truth** — stories are written alongside the component source code, so examples are always up to date.
- **Extensible tooling** — we can add new testing and documentation addons as the ecosystem evolves.
## The Playground
Each component page now features a **Playground** story as the default example. The Playground embeds Storybook directly into the docs site with the controls panel open, so you can tweak every property, slot, and variant without leaving the page.

### Controls panel
::div{.n:grid.n:m:grid-cols-2.n:gap-m.n:items-start}
:::div
The controls panel is generated automatically from the component's custom elements manifest. Every property, attribute, and slot is represented as an interactive control — selects for enums, toggles for booleans, text inputs for strings, and more.
:::
{.n:border.n:border-default.n:rounded style="max-width: 320px;"}
::
### Theme switching
::div{.n:grid.n:m:grid-cols-2.n:gap-m.n:items-start}
:::div
A theme selector in the toolbar lets you preview components across all four Nord themes:
- **Nord** (default light)
- **Nord Dark**
- **Veterinary**
- **Veterinary Dark**
Theme switching works in both the embedded playground and the standalone Storybook.
:::
{.n:border.n:border-default.n:rounded style="max-width: 320px;"}
::
### Viewport testing
::div{.n:grid.n:m:grid-cols-2.n:gap-m.n:items-start}
:::div
Storybook's built-in viewport tool lets you preview components at different device sizes — from mobile to desktop — directly in the canvas. This is especially useful for responsive components like Layout, Navigation, and Popout that adapt their behaviour based on screen width.
:::
{.n:border.n:border-default.n:rounded style="max-width: 320px;"}
::
### Accessibility testing
::div{.n:grid.n:m:grid-cols-2.n:gap-m.n:items-start}
:::div
Every story is automatically audited using the **Accessibility addon** powered by axe-core. Open the Accessibility panel to see a live report of any violations, incomplete checks, or passed rules for the current story state.
:::
{.n:border.n:border-default.n:rounded style="max-width: 320px;"}
::
### Autodocs
Storybook generates a full documentation page for each component, combining a live preview of every story with an auto-generated property table extracted from the custom elements manifest. This serves as a quick reference alongside our handwritten component guides.
### CodePen integration
Want to take an example further? Every story includes an **Open in CodePen** button — both in the docs site example viewer and in the Storybook toolbar. It exports the rendered HTML along with the correct CDN links for Nord CSS, themes, and components, so you get a working sandbox in seconds.
## For contributors
Stories live alongside their component source in `packages/components/src//`. Adding a new story is straightforward:
```ts
export const MyNewExample: Story = {
render: () => html`
Hello
`,
}
```
Run `npm run storybook` in the components package to start the development server. All 55+ components already have stories covering their key states and variants.
## What's next
This is the foundation we'll continue building on:
- **Visual regression testing** with Storybook's snapshot capabilities
- **Interaction testing** for complex component workflows
- **Design token documentation** within Storybook
- **Figma integration** linking stories to their design counterparts
We're excited about how Storybook transforms the way you explore and adopt Nord components. Try it out on any component page or open the standalone Storybook directly.
\[Open Storybook]\(/storybook/)
# May, 2021
You’re reading the second Nord Design System monthly update. Since February, we’ve been busy rethinking our design processes and brand identity that was launched a few weeks ago.
During the past months our team has been busy rethinking our brand identity from the ground up. We wanted to go through this effort to mirror the growth and transformation of our company into the leading cloud-based provider of healthcare and veterinary software. As a result, “Three Plus Group” and “Finnish Net Solutions” now have a new name and corporate identity and are now all called [Nordhealth](https://nordhealth.com){rel=""nofollow""}.
Our new logo represents “togetherness.” Two sides working as one. So, on a business level, it represents a key driver for us, acquisition. For our customers and end users, it expresses the seamless use of our products to improve productivity and communication. We bring healthcare professionals closer to their patients. Our new logo also defines how our teams work as a strong unshakable unit. On a deeper level, the logo also illustrates a bigger idea, change and innovation in the global healthcare market.
This rebranding is a start of a bigger design transformation at Nordhealth. Our plan isn’t to merely rethink the corporate brand. The goal is to continue this work and rethink our design processes and digital products from the ground up and improve their user experience and user interfaces vastly.
**This is where Nord Design System steps in. Nord is our platform for driving the design transformation.**
{.provet}
Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
Until the next time!
— Ariel
# Finalist for the Best Design System Award
Nord Design System was recently nominated for the Best Design System award at [Grand One competition](https://grandone.fi/kilpailutyot/?palkinto=voittajat&kategoria=paras-design-system) and won an honorable mention for the best developer experience.
[{.n-border.n-border-radius height="4032" style="max-width:600px;" width="3024"}](https://grandone.fi/kilpailutyot/?palkinto=voittajat&kategoria=paras-design-system)
\[View all finalists]\(https\://grandone.fi/kilpailutyot/?palkinto=voittajat\&kategoria=paras-design-system)
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# October, 2021
You’re reading the fifth Nord Design System monthly update. This month we’ve gained great momentum and have published four new packages, and made many improvements to Nord documentation.
As [Nord Design System](https://nordhealth.design) is still quite young, we feel like it’s a good idea to once in a while repeat why we are building these tools and what’s really the scope of our work. To us, a “design system” is a collection of reusable components and tools, guided by clear standards, that can be assembled together to build digital products and experiences.
What this means, is that we aren’t really designing the workflows and features of each product. Instead, our goal is to provide the best possible tools, components, and guidelines for our designers and developers working in each product team to be able to build more consistent products at scale, faster, and with better outcomes.
The ultimate end goal for us is to provide tools that allow us, [as a company](https://nordhealth.com){rel=""nofollow""}, to better serve our end users and that is really at the center of everything we do. We want to transform our culture, processes, and practices to support this mission and the design system is an important tool to help us with this transformation.
The fundamental purpose of Nord is to elevate our design and frontend development practices in-house, bring those disciplines closer together, improve the consistency between products, and also improve the working efficiency for everyone in the long run.
**We’re here to make your life easier, [let us know how we can help](https://nordhealth.design/resources/support/) your team.**
---
## New this month
As mentioned earlier, we’ve published quite a few [new packages](https://nordhealth.design/changelogs) and features this month, so we’re listing all of them below and linking to their respective documentation pages for detailed information about usage and such.
[](https://nordhealth.design/tokens/)
## Nord Design Tokens [1.0.0]{.n-badge.n-badge-l}
Design tokens are a tech-agnostic way to store variables. We use tokens instead of hard coded values to ensure a better UI consistency across different platforms. Design tokens reached stable state this week and they’re now ready for production usage.
\[View documentation]\(/tokens/)
---
[](https://nordhealth.design/design/themes/)
## Nord Themes [2.0.0]{.n-badge.n-badge-l}
Nord’s parts are themable using CSS Custom Properties. We ship pre-made themes for Nordhealth, Veterinary and Healthcare. You can utilize these themes through our Themes package which reached stable state this week and is now ready for production usage.
\[View documentation]\(/design/themes/)
---
[](https://nordhealth.design/icons/)
## Nordicons [1.0.0]{.n-badge.n-badge-l}
Nordicons are used to provide additional meaning or in places where text label doesn’t fit. They communicate messages at a glance and draw attention to important information. Nordicons package reached stable state this week and is now ready for production usage.
\[View documentation]\(/icons/)
---
[](https://nordhealth.design/docs/developer/webfonts/)
## Nord Webfonts [2.0.0]{.n-badge.n-badge-l}
Nord Design System provides an npm package that makes it straightforward to use our webfonts. This package ships with all the necessary font files in addition to Sass, Less, and CSS for self-hosting. Nord’s Webfonts package reached stable state this week and is now ready for production usage.
\[View documentation]\(/docs/developer/webfonts/)
---
[](https://nordhealth.design/docs/developer/cdn/)
## Nord CDN
We now serve all of Nord’s packages via a new Content Delivery Network for better performance and stability. Nord CDN also makes it faster to implement and use our packages in production.
\[View documentation]\(/docs/developer/cdn/)
---
::div{.n-theme-nord}
::
::div{.n-theme-nord-dark}
::
\> \[!WARNING]
\> We've added a new visual style to highlight specific content from the rest when needed.
## Improved documentation
We’ve worked on improving our documentation platform and added a handful of new features to make the daily usage nicer for everyone. The biggest changes include:
1. We’ve moved from global theming into a local theming. You can see this in action above and on e.g. our [Design Tokens documentation](https://nordhealth.design/tokens/) or on [Stack component page](https://nordhealth.design/components/stack/). No more hiding of content per theme, so all content is easier to discover.
2. All code examples now include “copy to clipboard” functionality. You can see this in action above and on e.g. [Themes documentation](https://nordhealth.design/design/themes/). Additionally, we’ve also added this functionality to the [Design Tokens](https://nordhealth.design/tokens/) documentation.
3. The search in the docs has been improved and it should now work much more reliably to make it quicker to find and discover content. Please note that when you search you can use arrow up/down keys and enter to select a result you want to open.
4. We’ve added a new visual style to highlight specific content from the rest when needed. There’s an example shown above this list.
5. The documentation itself is now using Nord Web Components so in a way we’re dog fooding ourselves with our own product to find issues and make it more robust.
6. There’s a lot of new content, including usage guidelines for [Design Tokens](https://nordhealth.design/tokens/#usage), [Themes](https://nordhealth.design/design/themes/), [Webfonts](https://nordhealth.design/docs/developer/webfonts/), [Nordicons](https://nordhealth.design/icons/), [Nord CDN](https://nordhealth.design/docs/developer/cdn/) and [more…](https://nordhealth.design/docs/developer/)
---
Until the next time!
— Ariel
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Finalist for the Jamstack Conf Jammies
Nord Design System was recently nominated for the Jamstack Conf Jammies award in “Project of the Year” category. Winners will be announced live at [Jamstack Conf](https://jamstack.org/conf/jammies/) on November 7 – 8.
Nord was nominated for outstanding achievement in delivering best-in-class experiences to customers through innovative use of technologies across the Jamstack and its ecosystem. You can read more [about the award on the official website](https://jamstack.org/conf/jammies/){rel=""nofollow""}.
[{height="1536" width="2027"}](https://jamstack.org/conf/jammies/)
\[View all finalists]\(https\://jamstack.org/conf/jammies/)
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.
# Explore and Create Themes for Your Team
\*The new \[Themes gallery]\(/themes) gives designers a place to explore different directions for their product. Choose a starting point, shape it in the theme playground and copy the CSS when you're ready to use it.\*

## Start with a theme
Themes change more than the accent colour. Typography, backgrounds, spacing, borders and corner shapes all contribute to how an interface feels.
The gallery brings those choices together in presets with distinct styles. Preview them in an app shell with dashboard cards, tables and notifications, so you can judge a theme in context.
## Make it your own
Open the [theme playground](https://nordhealth.design/themes/playground) to refine a preset. The preview comes first; open **Customise tokens** when you want to make more detailed changes.
- **Colours:** adjust surfaces, text, accents, borders and status colours with colour pickers and editable values.
- **Typography:** browse Google Fonts with typeface previews, then see your choice applied to the example interface.
- **Spacing and sizes:** use sliders and compact inputs to tune the density and proportions of the layout.
- **Shape and detail:** adjust corners, borders and shadows to bring the theme together.
Token groups stay visible as tabs, related controls sit together, and the editor panel can be resized. Each token has a description beside its label and a reset action if you want to undo an individual change.
For a fresh direction, try **Randomise**. It varies fonts, colours, backgrounds, spacing and shape, including darker palettes and borderless styles. Treat the result as a starting point: check readability and interaction states before using a theme in your product.
Your customisations are saved in the current browser, so you can return to your draft later.
## Take the CSS into your project
Choose **Use this theme** to inspect and copy the theme's CSS custom properties. Apply them in your application's stylesheet, and include any Google Fonts import provided with the theme. There is no JSON conversion step.
The theme preview helps you explore the direction; your application's content and workflows are the next place to check it.
## Keep exploring components
The top-level [Playground](https://nordhealth.design/playground/) opens Storybook, where you can try individual components and their controls. Themes has its own home at [/themes](https://nordhealth.design/themes), with the theme editor linked from the gallery.
[Explore the themes](https://nordhealth.design/themes) or [create your own](https://nordhealth.design/themes/playground).
# September, 2021
You’re reading the fourth Nord Design System monthly update. This month we’ve been working on making sure that everyone at Nordhealth understands how and why we’re building a design system.
We started the design systems work at [Nordhealth](https://nordhealth.com){rel=""nofollow""} in late 2020. The way I usually recommend starting this work is via user research, which helps us to figure out what are the challenges on organization, team, and people level that we should be solving. We do this because all companies are different and there isn’t one solution that fits everyone when it comes to design systems.
Back then we interviewed \~60 different persons from different teams, with different backgrounds, and with different levels of experience. The result of this research was an organizational challenges heatmap that highlighted organization level problems.
Now that we had a clear list of challenges that we wanted to start solving, it was a matter of creating fundamental principles and goals for the system that we should follow to start solving these issues. We came up with these four goals for Nord:

At the same time, we also created design principles for the design systems work that would form the foundations for Nord and guide our team when working on the different parts of the system and help us do better and more informed decisions. These are the six design principles we created for Nord:
### 1. Put user needs first
We care for the people who use our products. We’re here to make their day-to-day and long-term work better and more pleasant through great user experience.
### 2. Strive for consistency, not uniformity
We should use the same language and design patterns wherever possible. This helps people get familiar with our services. Same holds true for the system and its developer experience.
### 3. Default to openness
We should share what we’re doing whenever we can. Building our services transparently increases their visibility and accountability and makes us push towards higher quality.
### 4. Make it accessible
Our services are for everyone. We make sure people with different needs can use our products and that they meet the accessibility standards outlined in WCAG 2.1.
### 5. Provide a good developer experience
Providing a good developer experience is very important to us. Developers should be able to start using our tools in minutes, not hours, days or weeks.
### 6. Automate everything you can
We value the time of our colleagues, users, and our future selves over our own. We are always proactively looking for ways to automate repetitive tasks and testing.

Whenever I talk about Nord Design System, one of the first things that I like to mention is that we’re building a system that is **tech agnostic, not tech specific.** Meaning that you can take any component from Nord and use it with any framework. That could be Angular, React, Preact, Vue.js, plain HTML, your old PHP application, or any future framework.
We achieve this by building on top of existing web standards ([Web Components](https://developer.mozilla.org/en-US/docs/Web/Web_Components){rel=""nofollow""} to be exact), instead of choosing a specific framework to go with. This is really important for us for a few reasons;
### Tech-Agnostic Instead Of Tech-Specific
In order to create modular interfaces, a design system needs to be technology-agnostic instead of technology-specific. Web Components offer this benefit and make it easier to reduce our design system’s complexity and improve its reusability.
### Future Proofing With Web Standards
[Web Standards](https://en.wikipedia.org/wiki/Web_standards){rel=""nofollow""} are more future proof than any given JavaScript framework. I’ve seen different frameworks come and go during my almost two decade long career on the web, but Web Standards keep thriving and evolving.
### Any Framework Or No Framework
Web Components can be used with [any JavaScript framework](https://custom-elements-everywhere.com/){rel=""nofollow""} or no framework at all. This means we’re able to support all our product teams from a single codebase. This makes it possible for our small design system team to be very efficient.
### Full Encapsulation
[Shadow DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM){rel=""nofollow""} allows components to have their own DOM tree that can’t be accidentally accessed from the main document. For us this means that “everything just works” when the components are implemented onto different environments and platforms. Most styles cannot penetrate a component from the outside, and styles inside a component won’t bleed out.

Nord’s tech-agnostic thinking isn’t limited to only components either, all our styles are agnostic as well. We use [design tokens](https://nordhealth.design/tokens/) instead of hard coded values to ensure a better UI consistency across different platforms. Be that a web application, a native application, a mobile application, a VR solution, or something new that doesn’t even exist today.

Looking at the way [Nord](https://nordhealth.design) itself is structured, looks somewhat like shown in the picture above. The most important thing about the architecture is that we aren’t really talking about one gigantic design system, but multiple small modular systems that can be used either standalone or together depending on specific team’s needs.
So on a high-level we have design tokens which are the base building blocks of our design language. There we define things like colors, fonts, spacing, shadows, and other properties that create the visual look. Then on the second level we have packages such as Nord’s CSS Framework, Theme system, Web Components, and Figma components.
What ties it all together is our documentation and guidelines at [nordhealth.design](https://nordhealth.design) which is getting more and more automated as we move along.
[](https://nordhealth.github.io/nordhealth-pay-prototype/)
The last thing I perhaps want to share in this update, is an [early prototype](https://nordhealth.github.io/nordhealth-pay-prototype/) of Nord’s UI components. We’ve been moving back and forth between Figma and HTML prototypes to be able adjust the micro interactions and how the UI feels in real use in real environment, which is the web browser. Things will definitely still change quite a lot as we’re rapidly iterating on the design and theming, but [take a peek of what’s under work](https://nordhealth.github.io/nordhealth-pay-prototype/).
Until the next time!
— Ariel
P.S. Subscribe to our [RSS Feed](https://nordhealth.design/feed.xml){rel=""nofollow""} to follow the latest updates from Nord team.