Author: Brahim Van den Brande

  • Why we use WordPress and Astro to build better websites

    Why we use WordPress and Astro to build better websites

    WordPress and Astro can build better websites when each takes on the role it is best suited to.

    For a long time, building a website meant writing it by hand. HTML, CSS, PHP and JavaScript gave us direct control over every page and every detail. But they also made even small editorial changes dependent on a developer.

    When WordPress evolved, it solved a real problem. Clients could manage their own content. They could publish an article, update a service, add an image or correct a detail without waiting for us. That autonomy still matters.

    Then came page builders. We worked with WPBakery and moved early to Elementor. The promise was understandable: set up a library of well-designed components, give clients more freedom and make page creation easier.

    In practice, most clients did not want to become web designers. They wanted to manage their content and keep control of their data. When a new page, a more considered layout or an important change was needed, they still preferred to work with us.

    When one system has to do everything

    WordPress can be a very good editorial tool. The difficulty starts when the same installation is expected to manage content, define every visual layout, run a growing plugin stack and generate every public page on every visit.

    Over time, that can make a website heavier than it needs to be. Page builders and plugins are not automatically a problem, but a frontend built through years of additions often delivers more code, styles and scripts than a page actually needs.

    The result is harder to maintain and harder to improve deliberately. That matters because the public website should be focused. It should load cleanly, communicate clearly and reflect the quality of the organisation behind it.

    We kept WordPress. We changed its role.

    Today, we still use WordPress for many projects. It remains a familiar and practical place for clients to manage pages, articles, media, team profiles, services and structured content.

    The public-facing website is built separately with Astro. This is a headless setup: WordPress is the editorial backend, while Astro is responsible for the frontend visitors see.

    That separation is useful because each part can do its job properly.

    • WordPress gives editors a clear place to manage content
    • Custom post types and fields keep recurring content structured
    • Astro gives us precise control over layout, performance and code sent to the browser
    • The frontend can be built around the project rather than around a generic theme

    Most pages do not need to be generated on every visit

    Some website features need to be dynamic: a client portal, real-time availability, a checkout or personalised data. But most pages on an organisation’s website do not change every minute.

    A service page, a case study or an article can usually be generated when the site is deployed or updated. Astro allows us to do that while keeping dynamic behaviour for the parts that genuinely need it.

    Instead of treating the whole website as a live application, we decide what needs to be live. That creates a leaner public output and gives us more control over performance, image handling, metadata, structured data and the technical foundations of SEO.

    Autonomy without turning the website into a design tool

    A headless setup does not take control away from clients. It makes that control more useful. Clients can still manage their content, media, SEO fields and structured information. We define the editing experience around what their team actually needs to maintain.

    Some areas need freedom. Others need structure so the visual identity and the user experience remain coherent over time. Giving every editor unlimited layout control is rarely the same thing as giving them autonomy.

    A practical choice, not a fashionable one

    We do not use the same stack for every project. A small campaign page, a temporary site or a project with limited editorial needs may call for a simpler solution. The right architecture depends on the organisation, its content, its internal team and the role the website has to play.

    But when a client needs a website that is easy to manage, visually precise and technically controlled, WordPress and Astro are a strong combination. WordPress remains the editorial workspace. Astro becomes the public-facing website.

    That lets us keep what clients value about WordPress while building a cleaner frontend from the ground up.

  • When WordPress becomes a bottleneck for your website

    When WordPress becomes a bottleneck for your website

    When WordPress slows down your website, the problem is usually not WordPress on its own.

    WordPress is not automatically slow. It is also not automatically the wrong choice for a modern website.

    It is widely used for good reasons. Editors know it. It is flexible. It can manage pages, articles, media, forms and structured content. For many organisations, it remains a practical part of the digital ecosystem.

    The issue is usually not WordPress itself. It is what happens when one WordPress installation gradually becomes responsible for everything.

    The gradual build-up of complexity

    A website often starts simply. A theme is installed. A page builder is added. A form plugin, an SEO plugin, a cookie banner, a slider, an optimisation plugin and a few integrations follow. Each choice can be reasonable on its own.

    After several years, however, the website may carry a long history of decisions. Some plugins overlap. Some are no longer used. Some are required only because another plugin or a theme depends on them. The frontend may load scripts and styles for features that are not used on the page a visitor is viewing.

    That is when the website becomes harder to reason about. A small change can have unexpected effects. Improving performance becomes an exercise in working around accumulated layers instead of improving the structure at its source.

    Signs that the current setup is holding the website back

    • Pages are difficult to keep fast despite caching and optimisation plugins
    • Editors are unsure which components are safe to use
    • The design system slowly drifts as pages are assembled differently
    • Important updates require workarounds because the theme or builder has become restrictive
    • Several plugins exist for functions that should be part of the content model or frontend
    • It is difficult to explain what the website actually needs in order to run

    None of these signs means the site needs to be rebuilt immediately. They do mean that a technical review is worth having before the next redesign or content expansion.

    Content management and frontend delivery are different jobs

    Clients need an interface where they can manage their content. Visitors need a website that loads only what the page requires. Those are related needs, but they do not have to be solved by the same layer of the stack.

    In a headless setup, WordPress remains the content management system. It can still hold custom post types, fields, media, editorial workflows and SEO data. The frontend is built separately, for example with Astro.

    That means we can keep the familiar editing experience while reducing the amount of generic code and dependency logic that reaches the public website.

    Page builders solved a real need

    It is easy to criticise page builders in hindsight. That would miss the point. They helped many organisations move away from websites that could only be edited by developers. They made layout tools more accessible and gave teams a way to work with reusable blocks.

    But the kind of flexibility they offer is not equally useful for every organisation. Most teams do not need to design a page from a blank canvas. They need a dependable set of content structures that preserve the visual system and let them make the right updates quickly.

    That is a different form of autonomy. It is more constrained, but often more useful in practice.

    What to do before deciding on a rebuild

    Start with the actual problem. Is it performance, editorial workflow, visual inconsistency, security, maintainability or a combination of several issues?

    Then separate what needs to stay from what needs to change. Your existing content, WordPress familiarity and structured data may all be worth preserving. The public frontend, the plugin stack and the way pages are delivered may be the parts that need a different approach.

    A good rebuild is not a reaction to a trend. It is a chance to simplify the system around the organisation’s real needs.

  • Static vs dynamic websites: what actually needs to be live?

    Static vs dynamic websites: what actually needs to be live?

    Static vs dynamic websites are not a final either-or choice: it depends on what truly needs to stay live.

    The phrase “static website” can sound outdated. It suggests a site that cannot change, cannot be edited and cannot do anything beyond displaying a few pages.

    That is not what static means today.

    A modern static website can be connected to a CMS, use structured content, optimise images, include forms and keep selected features dynamic. The difference is simply that pages which do not need live computation are generated in advance rather than assembled from scratch every time somebody visits.

    Dynamic is useful when the information changes in real time

    Some parts of a website need to respond to live data or individual users. A client portal, an online booking system, a product stock level, a checkout flow or a dashboard cannot be prepared once and left unchanged.

    Those features need a dynamic system. The server or application has to generate the right response at the moment it is requested.

    But a large part of a typical organisation’s website is different. Service pages, team profiles, case studies, articles and contact information are usually updated occasionally, not every second.

    Most marketing pages are predictable

    When a visitor opens an about page, there is rarely a good reason to make the server rebuild that page in real time. The content can be generated when the site is deployed, then delivered as a prepared page.

    This has practical benefits. The visitor receives a more direct response. The website can be easier to cache and protect. The frontend can contain only the code and assets required for the page.

    It also gives us a useful design discipline: instead of adding a runtime layer by default, we ask whether the feature actually needs one.

    The right question is not static or dynamic

    In many projects, the best answer is both.

    The editorial pages can be generated in advance. A form can still submit to a secure endpoint. A search experience can use a targeted service. A booking widget can remain dynamic. Interactive elements can be added where they genuinely improve the experience.

    The point is to make each decision deliberately. A website should not carry the cost and complexity of a fully dynamic application just because one part of it needs to react in real time.

    How this works with WordPress

    WordPress can remain the place where content is written and managed. When content changes, the website is rebuilt with the new data. The next visitor sees the updated page, but does not need WordPress, the database and the editing interface to be involved in every page view.

    For the client, the editorial process remains familiar. For the visitor, the public website can be leaner and more focused.

    This model also makes it easier to set clear boundaries. WordPress is responsible for content. The frontend is responsible for delivery. Dynamic services are used only where they are needed.

    It is not about technical purity

    There is no virtue in making a feature static when it needs to be live. Equally, there is no benefit in making every page dynamic by default.

    The right architecture comes from understanding how the organisation works, what the visitor needs and what the team will need to maintain after launch.

    For many brand and marketing websites, a static-first frontend with selected dynamic features gives the best balance: editorial freedom, technical control and a more considered visitor experience.

  • How to choose a CMS without making your website heavier

    How to choose a CMS without making your website heavier

    To choose a CMS without making your website heavier, start with the way your team actually works.

    Choosing a CMS is often treated as a technical decision. It is not only that.

    A content management system affects who can update the website, how content is structured, what can be maintained internally and how much technical complexity the organisation takes on over time.

    That is why the right question is not “Which CMS is best?” It is “Which CMS fits the way this organisation needs to work?”

    Choose a CMS by starting with the people who will use it

    Before comparing platforms, look at the editorial reality. Who will publish content? How often will they do it? Are they comfortable working with structured fields, or do they need a very simple interface? Does the team need to create new types of content, or mainly update existing pages?

    A CMS should make these tasks clearer, not introduce a new technical responsibility for the people who use it.

    For many organisations, WordPress remains a sensible choice because it is familiar and flexible. It can support pages, articles, projects, services and custom content models without requiring the whole team to learn a new environment.

    Do not confuse content freedom with layout freedom

    There is a difference between being able to update content and being able to redesign a page.

    Most clients need to change titles, text, images, links and structured information. They may also need to add an article, a case study or a team member. These are editorial tasks.

    Giving every editor unrestricted layout control can look empowering, but it can also make a website harder to keep consistent. The visual system slowly shifts. Components are used in unintended ways. Important pages lose the structure that made them easy to read.

    A good CMS setup gives people the freedom they need while protecting the parts that should remain coherent.

    Define the content model before selecting plugins

    Many websites become complex because the content model is never made explicit. A new need appears, a plugin is installed, then another exception is added later.

    It is usually better to begin with the recurring content types. What does the organisation need to manage repeatedly? Services, projects, people, articles, events, locations, resources or testimonials?

    Once this is clear, those things can be represented as structured content. That makes editing easier and gives the frontend reliable information to work with.

    Consider the public website separately

    A CMS is the place where content is managed. It does not have to dictate how every public page is delivered.

    In a headless setup, WordPress can remain the editorial backend while a dedicated frontend such as Astro handles the website itself. This is useful when performance, visual precision, multilingual delivery or long-term frontend control are important.

    It allows us to preserve a familiar CMS without forcing the public website to carry the full technical weight of the backend, theme and page-builder layer.

    Ask practical questions before making a decision

    • Who needs to edit the website and what do they need to change?
    • Which content should be structured rather than created as one-off pages?
    • Which integrations are essential and which are only nice to have?
    • Does the website need to support several languages?
    • Which parts need to be dynamic in real time?
    • How will the system remain understandable after launch?

    These questions lead to better decisions than choosing a platform because it is familiar, fashionable or recommended in a generic comparison article.

    The CMS should serve the website, not burden it

    The goal is not to use the newest tool or build the most technical stack. The goal is to give the organisation a dependable editorial system and a website that remains clear, fast and maintainable.

    For many projects, that means keeping WordPress for content management and using a separate frontend for the public experience. For others, a simpler setup may be enough.

    What matters is that the technology supports the work. It should help the team manage content, help visitors understand the organisation and give the website room to evolve without becoming unnecessarily heavy.

  • Why we separate your CMS from your public website

    Why we separate your CMS from your public website

    To separate your CMS from your public website is to create a clearer boundary between content management and public delivery.

    Website security is often discussed as a list of tools: updates, passwords, backups, plugins and a firewall. All of those matter. But the architecture of a website matters too.

    When a traditional WordPress site serves its public pages, WordPress, PHP, the database, the theme and installed plugins are involved in the delivery path. They need to work correctly every time a visitor opens a page.

    In a headless setup, WordPress still manages content, but the public website is generated separately and delivered as static files. That does not make a website invulnerable. It does create a clearer boundary between the editorial system and the public frontend.

    Reducing exposure is different from removing risk

    WordPress remains a system that must be maintained. Core, plugins and themes need updates. Editor accounts need sensible permissions. Unused plugins should be removed. Backups need to be tested. The CMS itself must be protected as a serious operational system.

    But a static public frontend does not need to execute WordPress or PHP for every page view. The public website can serve the last approved build without asking the CMS to generate each visit in real time.

    This reduces the number of moving parts exposed through normal public browsing. It also means that an issue affecting the CMS does not automatically become an issue affecting every public page.

    What can stay online during a CMS incident

    If the CMS becomes unavailable, the public frontend may continue to serve the most recent safe build. Visitors can still read service pages, case studies and articles while the editorial system is investigated and restored.

    That is useful for continuity, but it is not a guarantee. The public website still depends on its hosting, DNS, CDN, deployment process, media delivery and any interactive services it uses. A compromised CMS must also be treated as an incident: access needs to be reviewed, credentials may need to be rotated, and restored data needs to be checked before a new build is deployed.

    The benefit is not that security work disappears. The benefit is that the impact can be contained more clearly.

    Where Cloudflare fits

    Cloudflare is part of that boundary. It can manage DNS and sit in front of public services as an edge layer. Used properly, it can apply targeted web application firewall rules, rate limits, bot protections and caching before a request reaches the origin.

    For a public marketing website, this can help reduce unwanted traffic and protect common sensitive paths. For a CMS, the policy should be stricter. The administration area, login routes, API endpoints, deployment hooks and other operational services should not be treated like ordinary public pages.

    Cloudflare is not a substitute for updating WordPress or reviewing plugins. It is one layer in a wider approach: a maintained CMS, limited access, tested backups, a protected origin, an intentional deployment process and a public frontend with fewer runtime dependencies.

    Security is also an operational question

    The most useful security decisions are often the least visible. They reduce unnecessary dependencies, separate public and administrative surfaces, make recovery more predictable and avoid giving one incident more reach than it needs.

    That is why we separate the CMS from the public website when the project calls for it. It gives editors a familiar place to work while allowing the public experience to remain focused, fast and less dependent on the CMS being available for every request.

  • Why we use less JavaScript when building websites

    Why we use less JavaScript when building websites

    To use less JavaScript on your website often means delivering a simpler, more robust experience.

    Not every website interaction needs JavaScript. That may sound obvious, but many websites still load scripts, libraries and components by default before asking whether they are actually needed.

    Our starting point is simpler: use semantic HTML for structure, CSS for presentation and interaction where CSS is the right tool, then add JavaScript only when it creates a real benefit.

    This is not nostalgia for older ways of building websites. Modern CSS can handle far more than it could a few years ago. Transitions, responsive layouts, filters, disclosure patterns and many interface states can now be built cleanly without turning every detail into a client-side application.

    Less JavaScript is a design decision

    Reducing JavaScript is not only about performance. It is about deciding what the website needs to do before deciding which technology to add.

    A simple interaction that works with semantic HTML and CSS is often easier to maintain, easier to test and less likely to fail on a slower connection or an older device. It can also keep the experience more predictable for visitors who use a keyboard, a screen reader or reduced-motion settings.

    JavaScript still has an important place. Some features genuinely need it: complex filters, maps, client portals, live data, enhanced forms or interactions that cannot be expressed properly through native browser behaviour. The point is not to avoid it. The point is to make it earn its place.

    Start with the page the visitor receives

    When we build a static-first frontend, the first version of the page is already useful HTML. The structure, headings, content and links are available before extra client-side behaviour is added.

    This gives us a clearer base for accessibility and SEO. It also makes it easier to see what every page is actually sending to the browser. A page should not carry a large interface framework, animation library or tracking stack simply because one small part of it is interactive.

    Performance is more than a score

    Performance tools are useful because they reveal problems: heavy images, unnecessary scripts, blocking resources or unstable page layout. But a score is not the objective by itself.

    The objective is a website that feels direct and dependable. Images and videos should be delivered at an appropriate size. Non-essential scripts should not block the first page view. Interactions should feel intentional rather than decorative. The page should remain understandable before everything has loaded.

    Accessibility and consent belong in the build

    Accessibility is not something added after the interface is finished. It starts with meaningful HTML, logical headings, keyboard behaviour, clear labels, sufficient contrast and a design that does not depend on one specific way of using a device.

    The same applies to consent and tracking. A cookie banner is not a decorative legal layer. It needs to control when non-essential tracking technologies are activated. The implementation should make that behaviour visible and testable.

    A lean frontend does not guarantee accessibility or compliance. It makes the system easier to inspect, test and improve because fewer hidden layers are working against the page.

    Technical quality is built through choices

    We use tools to test accessibility, performance, SEO and page quality. Those checks are useful, but they do not replace judgement. A high score does not automatically make a website clear, accessible or effective.

    What matters is the discipline behind the result: choosing the smallest useful solution, handling media carefully, respecting browser standards, adding code for a reason and testing the delivered website rather than trusting the source alone.

  • Who owns your website, data and digital tools?

    Who owns your website, data and digital tools?

    Who owns your website, data and digital tools? It is a question of continuity, not a technical detail.

    A website is never only a website. Behind it sit a domain name, hosting, a CMS, email, data, forms, analytics, sometimes a CRM, automations and several technical accounts.

    When these elements are poorly distributed or undocumented, an organisation can become dependent on an agency, provider or platform without ever making that choice deliberately.

    We believe a good partner should make an organisation stronger. It should not make that organisation less able to evolve, recover its data or work with another partner when needed.

    Who owns your website in practice?

    This is not about hosting everything yourself

    We do not promote open source as an ideology, nor self-hosting at any cost. A dependable SaaS product can be the right choice for email, CRM, collaboration or transactional delivery.

    The real question is reversibility. Can the data be exported? Does the client own the important accounts? Is the setup documented? Can the organisation change partner or tool without starting again from zero?

    What staying in control looks like

    Why we sometimes prefer open-source foundations

    Tools such as WordPress and Astro can help us build websites that remain under the organisation’s control. They are not the right answer to every need. But they rely on known technologies that can be maintained without dependence on one editor.

    We also consider self-hostable alternatives when they have a clear purpose, active maintenance, serious documentation and a credible level of maturity. We do not choose a tool because it has just appeared. We look for tools with a realistic place over time.

    The right solution depends on the context

    An organisation does not need to turn every tool into a technical project. It needs a system that works, remains understandable and supports the business.

    We help clients map the whole picture: registrar, DNS, hosting, CMS, email, CRM, automations, data and access. Then we recommend what fits, whether that is open source, self-hosted or SaaS.

    The aim is simple: build an environment that helps you work today without unnecessarily closing your options for tomorrow.

  • Is a compliant website really accessible?

    Is a compliant website really accessible?

    I still often see accessibility treated as a final step: an audit is commissioned, the reported issues are fixed, and the website is then considered accessible. That is a good start. But, for me, it is not enough proof.

    A website can meet a large proportion of the WCAG success criteria and still be frustrating, confusing or impossible to use for a disabled person. When I work on a website, I am interested in a more practical question: can someone find the information, understand what is expected of them and complete what they came to do without having to ask for help?

    That distinction guides how I approach accessible website design. Standards provide an essential framework. But they cannot replace observing how people actually use a service.

    Accessible website design: why I do not stop at WCAG compliance

    The WCAG have given teams, organisations and regulators a shared language. They provide specific reference points: text alternatives, keyboard navigation, contrast, heading structure, error messages, focus states and text resizing. Without that framework, everyone would decide for themselves what is acceptable.

    So I do not set them against user experience. On the contrary, they are the foundation I aim to build in from the design stage. But a standard checks conditions. It cannot, by itself, experience an entire user journey.

    An element may be technically keyboard accessible while the tab order remains illogical. Text may be enlarged without the page remaining genuinely readable or usable. A form may follow the markup rules and still leave someone without a clear answer when an error occurs. Compliance is a necessary minimum. It does not automatically guarantee usability.

    What tools and audits do not tell me

    Automated tools are useful. They help identify recurring defects quickly, monitor quality over time and prevent some obvious regressions from reaching production.

    But they read code and rules, not lived situations. They cannot tell whether a button label is ambiguous, a modal provides enough context, form errors are understandable, or someone can actually complete a task with the tools they normally use.

    That is why I do not limit the question to, “does the page pass?”. The useful question is: “can someone complete the action that matters without relying on outside help?”

    The ways of using a service that I try not to overlook

    When people discuss accessibility, they often first think of blind and partially sighted people. That is essential, but the subject is broader. An interface can also create barriers for deaf and hard-of-hearing people, people with reduced mobility, cognitive or learning difficulties, or people who use assistive technologies.

    I also try not to reduce the issue to permanent situations. Someone with an arm in a cast, a parent holding a child, or a person looking at their phone in noise or bright sunlight may encounter a context-related barrier. That does not minimise disability. It is a reminder that a service designed for different ways of using it is usually more robust for everyone.

    In practice, this means not depending on a single gesture, sense or speed of interaction. An important action should be possible with a keyboard as well as a pointer, with understandable labels, sufficient time and clear feedback about what has just happened.

    Movement should help, not demand attention

    I am not trying to remove every animation. A transition can explain that a panel has opened or that a form has been submitted. But continuous, automatic or decorative movement can distract from the task and make concentration more difficult for some people.

    The prefers-reduced-motion system preference makes it possible to offer a calmer version to someone who has chosen to reduce animations on their device. For me, the right question is simple: does this movement help someone understand, or does it demand attention without providing useful information?

    I test a journey, not just a page

    For an organisation, the useful question is rarely, “is our website accessible?”. I prefer to ask: can someone actually complete the tasks that matter? Find important information, compare an offer, contact the organisation, fill in and correct a form, book, pay or follow up a request.

    This approach exposes what an isolated page can easily hide: implicit instructions, poorly announced changes of context, vague buttons, errors that are hard to correct, or steps that depend on visual information alone.

    Testing with disabled people can reveal these barriers in very concrete ways. It does not replace a serious WCAG assessment, just as a single person’s feedback cannot represent every way of using a service. The W3C recommends combining the involvement of people concerned with conformance evaluation. That combination seems the most honest approach to me.

    Why I prefer to discuss cost at the start of a project

    Taking accessibility seriously takes time, skills and sometimes a dedicated budget. Building robust components, reviewing content, testing with a keyboard, fixing forms and checking critical journeys are part of the work. Bringing in an independent body for an audit, or organising tests with disabled people, also adds a cost.

    I prefer to say that from the outset rather than presenting accessibility as an easy option to add at the end. An independent audit, such as those offered by AnySurfer, is a paid expert assessment service. Usability testing has a separate budget: scenarios must be prepared, participants recruited and paid, sessions facilitated, findings analysed and then addressed.

    That does not mean every website must immediately fund a label or a full user study. The appropriate level of effort depends on the service, its audience, the risks and the applicable obligations. But the choice should be deliberate. Leaving the issue until the end often means discovering structural problems when they are more expensive to fix.

    In Belgium, digital accessibility is already a legal obligation for public-sector services. Since 28 June 2025, some consumer-facing private services, including e-commerce, have also been covered by new European requirements. These obligations do not simply depend on the size of a business: they depend on the service offered and the intended audience. The Federal Public Service Economy guidance explains, among other things, the framework that applies to e-commerce in Belgium.

    What I take from WCAG and AnySurfer

    WCAG 2.2 remains a very useful quality baseline today. The work under way on WCAG 3 also points to an interesting shift: more attention to users’ functional needs and the outcomes they need to achieve, rather than only a list of technical checks.

    I also value AnySurfer’s approach in Belgium because it connects the skills of the teams, the quality of the delivered product and the client’s ability to maintain that quality over time. An interface does not stay accessible by magic once it is live. Content changes, new features appear and teams change.

    In 2023, I completed AnySurfer’s Web accessibility training for developers. Not to present myself as an all-knowing expert, but to better understand my responsibilities as a developer and keep improving my practice.

    How I approach accessibility at Fauves

    I do not see accessibility as a perfect state that can be reached once and for all. It is ongoing attention: checking, correcting, learning and doing better at every stage.

    • Define the critical journeys. Identify the tasks that must not leave anyone behind.
    • Design with accessible principles. Plan robust components, understandable content, visible states and consistent navigation.
    • Check regularly. Combine manual review, automated tests and checks against the relevant WCAG criteria.
    • Test when the project warrants it. Observe concrete tasks with people concerned and incorporate their feedback early enough to make changes.
    • Maintain quality. Train the people who publish content, document decisions and recheck changes to the website.

    At Fauves, I want to keep making this approach more concrete, more verifiable and more sustainable, including by starting the steps needed to obtain an AnySurfer label.

    Key takeaway

    A compliant website is better than a non-compliant one. But a genuinely accessible website is not judged by its code compliance alone. It is judged by whether people, in all their diversity, can understand, navigate and take action without encountering unnecessary barriers.

    Standards point the way. The people concerned tell us whether we have got there.

  • Web accessibility and design systems: building inclusion into every component

    Web accessibility and design systems: building inclusion into every component

    Web accessibility is more reliable when it is built into the design system rather than added at the end. That does not automatically make every interface accessible. Shared components, rules and tests do, however, prevent the same mistakes from recurring from one screen to the next.

    An unclear button, a field without a label or a modal that cannot be closed with a keyboard are not small isolated flaws. If the same component appears on ten screens, the problem appears ten times. A well-defined component provides a safer starting point for every new page. That is a very practical function of a design system.

    Turn an intention into a reusable rule

    Saying “we need to think about accessibility” does not guide a team. That intention needs to become choices that are visible in mockups, documented in the system and verifiable in the product. Start with what appears everywhere: buttons, links, form fields, alerts, tabs, menus, modals, cards and tables.

    For each component, the design system should define its purpose, permitted variants and states. A button is not just a colour and a label. It can be active, hovered, focused, disabled, loading or unavailable. A field can be empty, completed, required, invalid or valid. If these situations are neither designed nor named, they will often be improvised during development.

    The logic of atomic design helps apply the same behaviours from one element to the next.

    Design components around their real states

    A useful component shows what happens when someone acts, hesitates or makes a mistake. For an email field, for example, the system should provide a visible label, an indication of the expected format when it helps, error handling and text that explains the error. Red alone is not enough. There needs to be a clear message associated with the relevant field.

    The same principle applies to alerts. A success, error or information notification must be understandable through its text and context, not only through an icon or colour. A trash icon needs an accessible name when it triggers an action. A decorative pictogram, by contrast, should not add noise for readers.

    Component decision What to document in the system What to check in the product
    Button Action label, focus and disabled states, loading behaviour Usable with a keyboard, understandable action, visible focus
    Form field Label, help text, required status, error and input example Message linked to the right field, clear error, consistent reading order
    Modal Trigger, title, closing behaviour, focus return Opens and closes with a keyboard, focus kept within the modal
    Navigation Active state, submenus, labels and item order Predictable journey, access without a mouse, explicit links

    Keyboard access and focus are not technical details

    Many interfaces feel smooth with a mouse, then become confusing as soon as the Tab key is used. Keyboard navigation must therefore be part of the design scenarios. Focus should follow a logical order, remain visible and not disappear behind an animation or a colour that is too subtle.

    Labels, errors and contrast that genuinely help

    Web accessibility also depends on simple words. “Submit” is often clearer than “OK”. “Create my account” describes the action better than an arrow on its own. Labels should state what will happen. Help text should resolve a specific hesitation.

    Errors need the same care. “Error” says neither what is preventing progress nor how to fix it. “Enter an email address in the format name@domain.com” gives direction. The system can provide a message structure, but content teams need to adapt it to each situation.

    For contrast, plan colour pairs for text, surfaces, borders and states. An attractive palette does not guarantee that every use will work. Test text against its actual background, including links, focus states, secondary buttons and status messages. Colour should reinforce information, never be its only carrier.

    Make content, design and development work together

    An accessible design system is not the responsibility of one discipline. Content teams define useful labels and errors. Designers create states and priorities. Developers choose appropriate structure and behaviours, then check the result in the browser. The same rule must be understandable to all three disciplines.

    On SourceHub, Fauves worked with the product and development teams, aligning mockups, wording and micro-interactions with the product’s mission and technical constraints, through to development.

    A brand system and a design system also benefit from working together. Our article on the link between a brand system and a design system shows how shared rules can preserve consistency from one touchpoint to the next. In accessibility, this also applies to words, contrast, components and behaviours.

    Document and test at every stage

    Documentation should not be limited to a library of screenshots. For each component, it can state when to use it, when not to use it, the content it needs, the states to provide, keyboard rules and error examples. A short, concrete rule is easier to follow than a vague instruction.

    Testing complements that documentation. Check new components in real cases: keyboard navigation, focus visibility, message comprehension, contrast in different states and behaviour on mobile. Automated tools can spot some issues. They cannot judge whether a label is clear or whether a journey is logical. A manual review remains necessary.

    A practical checklist before adding a component

    • Is its purpose and use clearly defined?
    • Are all useful states designed and named?
    • Can it be reached and used without a mouse?
    • Is focus visible and placed logically?
    • Do the labels explain the action or information?
    • Do errors state what to correct and how?
    • Does the information remain understandable without relying only on colour?
    • Are the rules documented for content, design and development?
    • Has the component been checked in a real interface?

    Resources

    For a closer look at the core principles and recommendations, consult the Web Content Accessibility Guidelines (WCAG) from W3C. They provide a useful foundation for organising discussions, design criteria and checks throughout a project.

    Are you building or redesigning a digital product? Fauves can help you turn inclusion principles into design and development decisions that fit your existing system. Let’s talk about your project.

  • Atomic design: structuring interface components as a product evolves

    Atomic design: structuring interface components as a product evolves

    Atomic design helps an interface evolve without redesigning everything for every new page. It organises reusable elements: buttons, fields, cards, content blocks and templates. When a page changes, the team knows what to reuse, what to adapt and what to maintain.

    Think of the interface as something that can change

    An interface rarely stays still. An offering becomes clearer, a journey gets shorter, a feature appears, a team shifts its priorities. Without a structure, adjustments pile up: a slightly different button, a card tailored to one page, a typography rule forgotten in a file, mobile behaviour addressed too late.

    Atomic design offers a practical response. It breaks the interface into components that are simple enough to understand, complete enough to reuse and documented enough to change without surprises. A form field, for example, is not just a border and text. It includes its states, label, helper text, error message, keyboard behaviour and mobile version.

    The vocabulary popularised by Brad Frost, atoms, molecules, organisms, templates and pages, can act as a guide. It should not become doctrine. Some teams will be more comfortable with “foundations”, “components”, “sections” and “pages”. The goal is not to classify every element perfectly. It is to make dependencies visible and to reuse the same decisions.

    Atomic design, design system and brand system: three distinct roles

    These ideas complement each other, but they do not mean the same thing.

    • Atomic design structures the way an interface is composed. It helps decide what becomes a component, what belongs in a variant and what remains specific to a context.
    • The design system brings together components, rules, documentation, accessibility principles, usage guidelines and governance. It can draw on atomic design, but does not have to.
    • The brand system frames how the brand is expressed: tone of voice, visual identity, hierarchy, motion, iconography, editorial rules and adaptation across channels. It guides the interface, but goes beyond it.

    In practice, the brand system answers: “How is the brand recognised and how does it adapt?” The design system answers: “How does the team design and deliver consistently?” Atomic design answers: “How do interface building blocks fit together without multiplying unnecessarily?” To explore the relationship between the first two levels, read our article on the brand system and the design system.

    Put the method to work for the product

    Do not start with an empty component library. First, look at the screens and journeys that matter. Where do the same patterns recur? Which elements actually change with context? Which decisions are creating inconsistencies or slowing development today?

    Step Decision to make Useful deliverable
    1. Audit Identify recurring patterns and duplicates. Screen audit and component list.
    2. Define foundations Set rules for colour, typography, spacing, grid and states. Documented tokens or baseline rules.
    3. Compose Group elements that serve a clear use case. Components with limited variants.
    4. Test in journeys Check that components support real cases, including on mobile. Reference screens and usage feedback.
    5. Evolve Clarify who decides, documents and deprecates. Simple contribution rules.

    This progression avoids two pitfalls: creating an abstract catalogue that answers no need, or allowing every page to become an exception. A card does not necessarily deserve to become a standalone component when it first appears. But when the same need returns across several journeys, it is better to formalise it than to improvise each time.

    Decisions and risks to own

    A set of components does not remove choices. It makes them explicit. Before creating a variant, ask whether it answers a lasting need or a one-off circumstance. Before adding a colour or spacing value, check whether the existing rule is truly insufficient. This discipline keeps the system readable.

    • Risk of over-componentisation: breaking things down too far creates assemblies that are hard to understand. Keep components focused on an identifiable use case.
    • Risk of infinite variants: every added option increases the cost of testing, documentation and maintenance. Prefer intentional choices to universal properties.
    • Risk of a design-development gap: a component designed without behavioural rules is not enough. Define its states and constraints with the people who will build it.
    • Risk of late accessibility work: contrast, focus, error messages and keyboard navigation must be part of the component from the outset. Find the essential guidance in our article on accessibility and the design system.

    SourceHub: a structure built to move

    At SourceHub, the product evolved every week. Fauves developed the identity and interface with the project and development teams, rather than treating the brand as a layer added afterwards. The mock-ups, wording and micro-interactions were aligned with the product’s mission and technical constraints.

    This way of working called for a modular, adaptable brand. The components did not only save production time: they provided a shared framework for change while giving the product the flexibility it needed. Discover the SourceHub project.

    Resources

    Evolve without losing the thread

    A good set of rules does not prevent change. It helps teams make changes without losing consistency, speed or the purpose behind decisions. If your interface is growing faster than its rules, let’s talk about the structure to build.