Category: Design

  • UK Postcode Lookup UX: Where Checkouts Still Leak Customers

    UK Postcode Lookup UX: Where Checkouts Still Leak Customers

    Postcode lookup UX is the least glamorous part of a UK checkout and one of the most expensive to get wrong. Address autocomplete from services such as Ideal Postcodes and getAddress() is now cheap and easy to bolt on, so the problem is no longer whether you have lookup. It is how you have wired it into the form. If you run a UK shop, or build checkouts for people who do, this audit is for you.

    I will not quote an abandonment percentage for any single fix, because I have no trustworthy number to hand and neither, honestly, do most blog posts that do. What I can give you is the failure modes I would look for first, and how to test each one on your own analytics.

    Person completing a postcode lookup UX form on a laptop checkout page
    Photo by Julio Lopez on Pexels

    1. The lookup hidden behind a full address form

    The most common anti-pattern is showing every address field at once, with a small ‘Find address’ link tucked beside the postcode box. Shoppers see six empty fields and assume they have to type them all. Lead with one field, postcode or the first line of the address, and reveal the rest only after a selection or an explicit ‘Enter manually’ choice. Say your checkout has a mobile conversion problem: this is the first thing I would test.

    2. The postcode field that rejects valid input

    UK postcodes arrive in every shape: lowercase, with or without the space, with a stray trailing space from a phone keyboard. Strict regex validation that throws an error on ‘sw1a1aa’ is a self-inflicted wound. Trim whitespace, uppercase it, insert the space yourself, and validate shape rather than existence. Remember that new postcodes are issued regularly, so a stale local list will reject real addresses.

    3. Lookup that fails silently

    APIs time out. Keys expire. Quotas run out. If the lookup request fails and the form simply shows nothing, the customer thinks their postcode is wrong. Always fall back to manual entry with the fields visible, and log failures so you hear about them before customers do. Both Ideal Postcodes and getAddress() return clear error responses, so you have no excuse for a blank dropdown.

    4. Choosing between Ideal Postcodes and getAddress()

    Both are built on UK address data and both offer postcode lookup and a type-ahead style autocomplete, with client libraries and plain REST endpoints. The practical differences are pricing model, data licensing terms, and how the UI components behave. Check each provider’s current pricing and licence terms on their own sites, because they change. My rule: pick the one whose default UI you would be happiest shipping, since the data quality gap matters far less than a clumsy dropdown.

    5. Dropdowns that are a pain on a phone

    A native select listing thirty addresses is miserable on mobile. Better is a searchable list with large tap targets, where the house number or name is the first thing visible. Set inputmode and autocomplete attributes properly: autocomplete='postal-code', address-line1, address-line2 and address-level2 let browsers and password managers fill the lot in one tap.

    Close-up of a phone screen with an address suggestion list
    Photo by Ivan S on Pexels

    6. Fighting the browser’s own autofill

    Many shoppers have an address saved in Chrome, Safari or their password manager. A lookup widget that steals focus, or fields with non-standard names, blocks that shortcut. Autofill is faster than any API call. Keep standard autocomplete tokens and make sure that when autofill populates the form, your lookup stays out of the way instead of overwriting it.

    7. Flats, business names and the second address line

    Flats are where lookup earns its keep, and where it often breaks. Addresses like ‘Flat 3, 12 High Street’ can map awkwardly onto two lines, and sub-building or organisation names get dropped. Make sure your form keeps line one, line two and an optional company field, and test with a flat, a farmhouse with no street number and a business address. If the returned data lands in the wrong fields, the courier label will be wrong too.

    8. Making the case to the people who sign things off

    Address improvements are small, which makes them easy to deprioritise. Frame them with your own data: compare the funnel step from shipping page view to completion before and after, split by device. If your checkout also feeds order records into a customer database, it is worth thinking about how those address fields are stored and reused, and a specialist team like Dijitul Developments is the sort of place to ask about getting clean, structured addresses flowing into the systems behind the shop.

    How do you measure whether address fixes reduce basket abandonment?

    Track the shipping step as its own funnel stage, then measure drop-off, time on step and error-message counts before and after each change. Change one thing at a time and run it as an A/B test where traffic allows. Without that, a seasonal bump in November will convince you a fix worked when it did not.

    For the baseline, the Royal Mail’s own Royal Mail site is the authority on how UK addresses and postcodes are structured, and worth a read before you write any validation rule. If you work on forms more broadly, our piece on fintech onboarding flows covers similar friction trade-offs. Start by testing your own checkout on a phone with a flat address, and fix whatever annoys you first.

    Frequently Asked Questions

    What is the best postcode lookup API for UK e-commerce?

    Ideal Postcodes and getAddress() are both widely used and reliable for UK addresses. The better choice depends on pricing, licence terms and how their UI components fit your checkout. Trial both with real addresses, including flats and rural properties, before committing.

    Should I validate postcodes with a regex?

    Only loosely. Trim spaces, convert to uppercase and check the general shape, but never reject a postcode just because it is not in your own list. New postcodes are issued regularly, and strict rules turn valid customers away.

    Is address autocomplete better than postcode lookup?

    Autocomplete lets people start typing the first line and pick a match, while postcode lookup needs the full postcode first. Autocomplete is often quicker on mobile, but offering postcode lookup as well suits shoppers who know their postcode by heart.

  • Designing Fintech Onboarding Flows That Satisfy FCA Compliance Without Destroying UX

    Designing Fintech Onboarding Flows That Satisfy FCA Compliance Without Destroying UX

    Regulatory weight and conversion rate sit at opposite ends of a very uncomfortable seesaw. The FCA mandates identity verification, risk disclosures, appropriate target market assessments, and explicit consent capture. Your head of growth wants a three-screen sign-up that takes under two minutes. Both of them are right, which is precisely what makes fintech onboarding UX FCA compliance UK work so genuinely difficult to get right. I’ve spent time across several fintech projects watching perfectly good onboarding flows collapse under the weight of legal requirements bolted on at the last minute, and the pattern is always the same: compliance treated as a decoration applied after the design is done, rather than a structural constraint built into it from day one.

    The good news is that the FCA’s requirements, read carefully, don’t actually demand bad UX. They demand specificity, honesty, and informed consent. A well-designed flow can deliver all three without feeling like a GDPR cookie banner multiplied by a mortgage application.

    Person holding smartphone showing fintech onboarding UX designed for FCA compliance in the UK
    Photo by Julio Lopez on Pexels

    Where most fintech onboarding flows go wrong structurally

    The most common structural mistake I see is treating every compliance step as a discrete screen break. Identity document upload on screen four, risk disclosure on screen six, consent checkboxes on screen nine. Each one feels like a toll booth, and users mentally clock every stop. The alternative is to think about compliance requirements as information architecture decisions, not interruptions. KYC document capture, for instance, can be sequenced after the user has already committed to a goal: they’ve told you they want to invest, they’ve seen projected outcomes, they understand what they’re signing up for. Asking for ID at that point feels earned rather than arbitrary.

    Sequencing is half the battle. The other half is copy. Risk warnings on UK-regulated products, particularly for investments and consumer credit, tend to arrive pre-written from legal teams in fonts small enough to require a magnifying glass and phrasing dense enough to require a law degree. The FCA’s Consumer Duty rules, which came into full effect for closed book products in July 2024, push firms to communicate in a way that customers can actually understand. That’s a design problem as much as a legal one. Breaking a risk statement into a short headline, a two-sentence plain-English summary, and a collapsible “full details” section isn’t hiding information; it’s presenting it in a hierarchy that matches how humans actually read. The full text is always there. It’s just not the first thing you see.

    Designing identity verification that doesn’t feel like airport security

    KYC is the step where onboarding flows lose the most users, and the drop-off is rarely because users don’t want to verify their identity. It’s because the experience makes them feel like suspects. A few principles I keep coming back to: tell users why you’re asking before you ask. “We’re required by UK law to confirm your identity before you can invest” lands completely differently to a cold request to photograph your passport. Frame it as protection for them, because it genuinely is.

    Camera and document capture UX deserves proper engineering time. Liveness checks from providers like Onfido or Jumio have their own SDKs with reasonable default flows, but the screens before and after them, the instructions, the error states, the success confirmation, are yours to design. Error states in particular are where I’ve seen teams get lazy. “Verification failed” is not a helpful message. “We couldn’t read the text on your document clearly; try in a well-lit space and avoid glare on the document surface” is. One of those recovers the user. The other sends them to your support queue or, more likely, away entirely.

    Re-upload flows need the same care. If a document is rejected at the provider level, the user needs to understand the specific reason, have a clear path to try again, and ideally be able to do so without starting the whole onboarding journey from scratch. Session persistence during KYC is not a nice-to-have. It’s conversion-critical.

    Passport and smartphone showing mobile identity verification as part of fintech onboarding UX FCA compliance
    Photo by Leeloo The First on Pexels

    Risk disclosures and target market assessments done without alienating users

    The FCA’s appropriateness and suitability requirements for investment and credit products mean you have to gather information about a user’s financial situation, knowledge, and risk appetite before they can proceed. Designed badly, this feels like a test they might fail. Designed well, it feels like personalisation. The difference is framing and feedback.

    Appropriateness questionnaires should show progress, explain why each question matters, and give contextual help for any term that might be unfamiliar. “What do you understand by ‘capital at risk’?” is a reasonable regulatory question. But if you don’t give users a way to learn the answer before they answer, you’re testing knowledge rather than ensuring understanding, which is a different thing entirely. An expandable tooltip or a micro-explanation card below the question adds maybe two hours of design time and measurably reduces incorrect responses that then generate even more friction downstream.

    For fintech onboarding UX FCA compliance UK to actually work at scale, risk disclosure copy needs to be tested with real users, not just approved by legal. The FCA doesn’t prescribe the exact format of most risk warnings; it prescribes what they must communicate. That leaves significant room for a design team to present legally sound information in a human way. I’d strongly recommend reading the FCA’s own Consumer Duty guidance directly, because the emphasis on “consumer understanding” as an explicit outcome gives you genuine leverage in conversations with legal teams who default to dense small-print.

    Consent capture without the checkbox graveyard

    There’s a pattern I call the checkbox graveyard: seven or eight tick-boxes at the end of onboarding, each one linking to a PDF document somewhere in the cloud, with phrasing like “I have read and agree to the terms, conditions, privacy policy, cookie policy, risk disclaimer, investment restriction notice, and marketing preferences.” Every one of those items deserves its own moment. Bundled together, they’re legally questionable under PECR and UK GDPR, and they produce consent that users don’t actually understand they’ve given.

    Disaggregated consent is both better UX and better compliance. Break it into distinct steps: contractual terms (one screen, with a summary of key points), risk acknowledgement (specific to the product type, not generic), and marketing preferences (entirely optional, clearly separated, no dark patterns). This feels longer in a flow diagram but shorter in practice, because each decision is clear and fast rather than vague and anxious. The same principle applies when designing for financial compliance more broadly: every regulatory requirement is an opportunity to build trust, not just a hurdle to clear.

    One practical note on marketing consent: do not pre-tick it. Not just because UK GDPR requires it to be active rather than pre-ticked, but because pre-ticked consent generates low-quality marketing lists that cost you more in email deliverability and engagement metrics than the marginal extra opt-ins are ever worth.

    Testing compliance flows without breaking your recruitment budget

    Usability testing on regulated flows has one specific challenge: you can’t just grab five people from your network and call it research, because the target market assessments your FCA authorisation requires are based on specific user segments. You need to test with representative users, people who match the financial sophistication profile your product is designed for. That takes slightly more recruitment effort, but the signal quality is worth it.

    Prototype early and ugly. Compliance copy is the one place I’ll argue for testing literally with legal team-supplied text before any design polish is applied. If users can’t understand the risk warning in a bare wireframe, a better colour palette won’t fix it. Get the words right first. The design layer makes good information clear; it can’t make bad information legible.

    It’s also worth thinking about how compliance-forward design thinking bleeds into adjacent industries. Organisations handling environmental reporting, EPC certificates, and energy efficiency commitments face their own disclosure-heavy regulatory requirements, and some of the same UX principles transfer. Compliance as copy clarity, progressive disclosure of dense information, and earned consent. Nottingham-based R2G.co.uk (https://www.r2g.co.uk/), which helps organisations make substantive changes to their energy and sustainability practices, including climate action planning and solar panel deployment, deals with its own form of compliance-laden client communication around energy saving targets and environmental obligations. The challenge of making regulation feel human is not unique to fintech.

    The fintech onboarding UX FCA compliance UK problem isn’t going away; if anything, Consumer Duty enforcement will tighten the expectations on how clearly regulated information must be communicated. But the firms that treat that as a design challenge rather than a legal obstacle tend to end up with better products. The constraints are real. So is the opportunity.

    For teams working on the visual systems underpinning these flows, the kind of rigorous colour and contrast thinking covered in how UK design teams are solving semantic colour token problems is directly relevant, particularly when you’re rendering risk warnings and legal text that must meet WCAG accessibility standards. Equally, if your onboarding has meaningful motion or state transitions, the production concerns from CSS scroll-driven animations in production apply to anything that animates between compliance steps. Smooth progress transitions are fine. Obscuring the fact that a user is looking at a risk warning is not.

    The firms getting fintech onboarding UX FCA compliance UK right are not the ones with the most aggressive conversion optimisation. They’re the ones that decided compliance legibility is a brand value, not a checkbox. That framing changes every design decision that follows.

  • How British Newspapers Are Redesigning Their Digital Subscriptions UX to Stop the Bleed

    How British Newspapers Are Redesigning Their Digital Subscriptions UX to Stop the Bleed

    British newspapers are in a genuinely fascinating position right now. They are simultaneously some of the oldest media brands on the planet and some of the most aggressive experimenters in digital product design. The Guardian, The Times, and The Telegraph have all had to figure out how you take a reader who once paid 50p at a newsagent and turn them into someone who feels good about a recurring monthly charge on their bank statement. That is not a trivial UX problem. I’ve spent a good chunk of time lately pulling apart their subscription flows, poking at their dashboards, and thinking about what the patterns actually reveal for product designers beyond the media world.

    Person reading a UK digital news subscription on a tablet, illustrating UK digital subscription UX design
    Photo by Letícia Alvares on Pexels

    The paywall is not the product, the moment before it is

    Every UK publisher has iterated endlessly on where to cut off free reading, but the more interesting design decisions happen in the friction zone just before the paywall triggers. The Times uses a metered model with a visible article counter, which does something psychologically clever: it turns scarcity into a UI element. You watch your remaining free articles tick down, and that countdown is doing real persuasion work without a single line of copy. The Guardian goes the opposite direction with its contribution model, which is a fascinating choice to study. There is no hard cut-off. Instead, a persistent but low-aggression banner asks you to fund journalism you are already consuming. The design hierarchy keeps content dominant and the ask secondary, which builds trust over time rather than manufacturing urgency.

    The Telegraph’s approach sits closer to The Times: a hard paywall with a clearly staged free trial CTA. What I find worth studying there is how the pre-paywall article experience is designed. Images load fully, the lede paragraph renders completely, and the truncation point is selected to land just after the reader has committed enough attention to feel the loss. That is not an accident. Someone made a deliberate call about where narrative investment peaks and placed the gate there. That is solid conversion thinking applied to editorial product design.

    What subscriber dashboards reveal about retention thinking

    Once someone subscribes, the dashboard becomes the product. And honestly, this is where UK publishers still have the most room to grow. I logged into The Times subscriber account area recently and the experience felt like it was designed by a different team than the one running the front end. The reading experience is genuinely polished; the account management section is utilitarian at best. Billing details, newsletter preferences, and device management all exist, but the information architecture feels like a compliance checklist rather than a designed space.

    The Guardian does marginally better here by surfacing reading history and letting subscribers access specific series or long-form pieces they have saved. That saved-content mechanic is doing important retention work: it gives people a reason to return to the account area, which reinforces the sense of an ongoing relationship rather than a passive payment. Any product designer building a subscription interface should be thinking hard about how the dashboard communicates ongoing value to a user who has already committed. The paywall converts; the dashboard retains.

    The data visualisation opportunity here is largely untapped. Imagine a subscriber dashboard that showed you your reading habits over the past month, surfaced topics you engage with most, and recommended content based on actual behaviour. Spotify does this obsessively. Netflix does it. UK publishers have the content depth to do it and mostly do not. There is a design pattern waiting to be built there, and whoever ships it first will have a meaningful retention advantage.

    Cancellation flows and the ethics of friction

    This is where UK digital subscription UX design gets politically charged. The dark pattern conversation has moved firmly into regulatory territory: the FCA and the Competition and Markets Authority have both signalled attention to subscription practices, and the Consumer Rights Act 2015 sets a clear baseline for what fair cancellation looks like. Hiding the cancel button five menus deep is not just bad UX; it is increasingly a legal risk.

    The Times handles cancellation reasonably well compared to some, routing you through a retention offer screen before confirming. The offer is visible, the decline path is clear, and the confirmation is immediate. That is a pattern worth copying. The Telegraph has historically made cancellation harder to find, and you can see the tension between the short-term churn number and the long-term trust cost playing out in the design. Designers working on UK digital subscription UX design in 2026 need to understand that friction-as-dark-pattern is a diminishing returns strategy. Readers talk. Screenshots spread. The reputational hit from a genuinely hostile cancel flow now outweighs the churn it prevents.

    The newsletter as a retention surface, not a marketing tool

    One pattern I find genuinely clever is how The Guardian and The Times have repositioned their newsletters as subscriber benefits rather than acquisition tools. The distinction matters in design terms. A marketing newsletter is designed to drive a click back to the website. A subscriber benefit newsletter is designed to complete the reader’s experience of a topic without necessarily requiring a click at all. The typography, the information density, the presence or absence of advertising, all of these differ between the two modes.

    For product designers, this is a prompt to think about how print-to-web design systems handle brand identity across formats when the same content organisation is producing editorial for multiple surfaces simultaneously. A newsletter that feels typographically coherent with the desktop reading experience is reinforcing brand investment. A newsletter that looks like it was knocked together in Mailchimp in 2019 is quietly eroding it.

    What product designers outside media can actually take from this

    The reason UK digital subscription UX design in the media sector is worth studying is that publishers are running these experiments at massive scale with genuinely impatient users. The Guardian has millions of readers. The Times has a base built on premium expectation. The data behind every micro-decision in these flows is enormous. That makes their patterns a reasonable proxy for what works in subscription UX more broadly.

    A few things I’d take directly into non-media product work. First, visible scarcity is powerful but only when it is honest. Fake countdown timers are a dark pattern; a real article meter is a design feature. Second, the account dashboard is not administrative overhead, it is a retention surface that deserves the same design attention as the acquisition flow. Third, design systems that span multiple content surfaces, whether email, app, or web, need a coherent typographic and colour token layer underneath them. I’ve written before about building a design token pipeline that can scale across surfaces, and honestly, it is the kind of infrastructure investment that pays back every time you add a new subscriber touchpoint.

    British newspapers got disrupted slowly and then very fast. The UX decisions they are making now to claw back subscription revenue are some of the most consequential product design work happening in the UK. That is worth paying close attention to, even if your product has nothing to do with journalism.

    Frequently Asked Questions

    What makes UK digital subscription UX design different from standard SaaS onboarding?

    Media subscriptions involve a fundamentally different value proposition: the user already consumes the product before paying, so the paywall moment carries more psychological weight than a free trial expiry. The design challenge is converting habitual readers into willing payers without breaking the trust built through that free consumption, which is a harder ask than converting a trialist who signed up expecting to pay.

    How do The Guardian and The Times differ in their paywall approach?

    The Times uses a metered hard paywall with a visible article counter, creating a scarcity mechanic that drives conversion through loss aversion. The Guardian runs a contribution model with no hard cut-off, using persistent but low-aggression prompts that keep content accessible while building long-term trust. Both approaches reflect deliberate UX strategy rather than technical limitation.

    Are hard-to-cancel subscription flows legal in the UK?

    UK consumer protection law, specifically the Consumer Rights Act 2015 and CMA guidance on subscription traps, sets clear expectations around transparent cancellation. Subscription services that bury cancellation options or use misleading retention flows face regulatory scrutiny, and several UK businesses have received CMA attention on exactly these practices in recent years.

  • Print Is Not Dead: How UK Editorial Designers Are Using InDesign and Variable Data Printing to Produce Hyper-Personalised Collateral

    Print Is Not Dead: How UK Editorial Designers Are Using InDesign and Variable Data Printing to Produce Hyper-Personalised Collateral

    There’s a particular kind of satisfaction in holding something printed. The weight of it, the slight resistance of the paper. I’ve been watching UK studios quietly rediscover that feeling, and what’s interesting is that it’s not nostalgia driving the movement. It’s data. Specifically, variable data printing editorial design UK workflows are getting genuinely sophisticated in ways that digital-first teams haven’t really caught up with yet.

    Budget is moving. Not dramatically, not in ways that make headlines, but in ways you notice when you talk to creative directors at mid-sized British publishers and brand studios. Some of them are shifting meaningful portions of their collateral spend back into print, and the reason is almost always the same: digital has become so cheap and so saturated that well-crafted physical mail actually stands out again.

    Editorial designer working on variable data printing editorial design UK project in InDesign with printed proofs on desk
    Photo by alleksana on Pexels

    What variable data printing actually is (and why it’s not just mail merge)

    Variable data printing, or VDP, lets a single print run produce thousands of unique documents. Each piece can have a different name, different image, different copy block, different offer, different layout. The data is pulled from a structured source, mapped to placeholders in a template, and the press (typically a digital inkjet or laser system) renders each version on the fly.

    People hear “variable data” and immediately think of those slightly creepy mailers from the early 2000s where your name appeared in the middle of a stock photo of a house. That was the technology at its clumsiest. What’s happening now in serious editorial design studios is much more considered. A good VDP workflow in 2026 treats personalisation as a design constraint, not a gimmick. The grid has to accommodate variation without breaking. The typography has to hold across name lengths from “Jo” to “Bartholomew”. The colour logic has to survive when the lifestyle image swaps from a 50-year-old in a garden to a 25-year-old in a flat.

    InDesign is still the dominant tool for building these templates. Adobe’s Data Merge panel is functional if a bit clunky, and most serious studios supplement it with scripts or use specialist VDP software like XMPie or Objectif Lune’s PlanetPress that can talk directly to InDesign’s document structure. The data itself usually lives in a CSV or comes via API from a CRM. GDPR compliance is, obviously, the first conversation anyone has before a campaign touches a database, and the ICO’s direct marketing guidance is worth bookmarking if you’re setting up a UK campaign for the first time.

    Grid discipline and why it matters more in print than on screen

    This is the bit digital designers consistently underestimate. On screen, a broken layout is a CSS bug, usually fixable in minutes. In print, a broken layout is waste. Expensive, irreversible waste.

    Serious VDP editorial design in the UK relies on grids that are genuinely stress-tested. A baseline grid isn’t optional, it’s structural. Every text frame has minimum and maximum character count rules baked into the data specification, because if a customer’s address runs to six lines instead of three, the whole composition shifts. Studios I’ve spoken to talk about “safe zones” for variable content, designing fixed anchor points that keep the piece visually coherent regardless of what the data throws at it.

    The grid discipline required for print VDP is, frankly, more rigorous than most web design systems I’ve seen. If you’ve read our walkthrough on building a design token pipeline with Style Dictionary, you’ll recognise the underlying logic: systematic constraints that scale. The difference is that in print, the constraints are physical, not just conceptual.

    Which UK studios and publishers are actually doing this well

    The publishing sector has been at this longest. Condé Nast UK and Immediate Media have been running sophisticated subscriber personalisation programmes for years, but what’s changed recently is that smaller independent publishers are now accessing the same level of workflow tooling. Print-on-demand infrastructure has dropped in price significantly, and the minimum viable run for a personalised campaign is now genuinely accessible to an independent magazine or a B2B publisher working with a list of a few thousand contacts.

    Charity direct mail has also had a quiet renaissance. Organisations that moved aggressively into digital fundraising between 2018 and 2023 found response rates collapsing as email inboxes became unmanageable. Several UK charities, including some household names, have returned to highly personalised print appeals that reference a donor’s specific giving history. The conversion rates on these, compared to equivalent digital touchpoints, are notable enough that they’re rebalancing budgets.

    On the brand side, a number of UK luxury and premium consumer brands, particularly in homeware, food and drink, and financial services, are investing in print that explicitly signals they’re not doing this digitally. A well-designed, personalised printed piece says something about a brand’s confidence that a triggered email sequence simply cannot.

    The InDesign workflow in practice

    A typical VDP project at a UK design studio starts with data mapping, before anyone touches InDesign. You audit the data fields available from the client’s CRM, decide which fields are reliable enough to use in personalisation (postcode segment, product category, donation history, subscription tier), and then design the logic rules: if field X is empty, fall back to Y; if field Z exceeds 30 characters, use abbreviated version.

    Template construction then follows standard InDesign editorial practice, except every text frame and image frame that will vary is tagged. Scripts handle the repetitive work of merging and preflight checking each record. Output is usually a batched PDF handed to the print supplier, or increasingly a JDF-compliant file that talks directly to the press.

    Colour management is where a lot of studios get caught out. RGB-to-CMYK conversion in a variable workflow can produce subtle inconsistencies across a run if profiles aren’t locked down at the export stage. ISO 12647-2 is the relevant standard for offset and digital print in the UK, and any serious print supplier will expect you to be working to it. If your studio is primarily digital-first, this colour discipline is genuinely different from preparing assets for screen, and it’s worth the investment in a proper profile workflow before your first print run.

    Why some UK brands are moving budget back from digital to physical

    The economics are worth examining clearly. A well-executed VDP direct mail campaign in the UK has a cost per piece somewhere between £1.50 and £5 depending on format, personalisation complexity, and run length. That sounds expensive next to a 0.3p email. But response rates on quality print campaigns from Royal Mail’s own research have consistently run at 3-5% for direct mail, against sub-1% for email in saturated categories.

    Physical print also doesn’t get blocked by an ad blocker, isn’t filtered into a promotions tab, and doesn’t disappear when a platform changes its algorithm. Those constraints matter quite differently once you’ve watched a Meta advertising account get suspended at short notice, or watched organic social reach collapse. Several UK brand teams I’ve spoken to describe print as a channel that’s predictable in a way that digital increasingly isn’t.

    There’s also a connection to how design systems are being thought about more holistically. Our article on how UK publishing houses are bridging print and web design systems covers the token and brand identity side of this in more detail, but the broader point is that studios are being asked to think across both surfaces again rather than treating print as an afterthought.

    What frontend and digital designers can take from this

    I’d argue the grid rigour and the data-conditional design thinking that VDP demands are directly transferable to component design on screen. The problem of “what does this layout look like when the content field is unexpectedly long?” is exactly the same problem you’re solving when you build a card component that needs to handle both a two-word label and a twelve-word one. If you’re working on UI systems, reading how print designers solve layout stress-testing is genuinely useful. It’s the same intellectual muscle.

    The personalisation logic also maps closely to what frontend teams are doing with edge-rendered conditional content, something we’ve covered in the context of Cloudflare Workers and Vercel Edge for UK web performance. The underlying idea, serving different content to different users based on structured data, is the same. Print just does it with ink and paper instead of JavaScript.

    Print isn’t coming back to displace digital. But for UK studios and publishers who’ve spent a decade assuming print was a diminishing line item, the numbers are making a reasonably compelling case for a second look. Variable data printing in particular has reached a level of tooling maturity where the design discipline required is genuinely interesting, and the results, when the grid work is done properly, are impressive in a way that a targeted push notification simply isn’t.

    Frequently Asked Questions

    What is variable data printing and how does it differ from standard print runs?

    Variable data printing allows each piece in a print run to contain unique content, such as different names, images, or copy, pulled from a data source like a CSV or CRM. Unlike a standard print run where every sheet is identical, VDP renders each record individually, making large-scale personalised collateral possible on a single press pass.

    Which software do UK studios use for variable data printing workflows?

    Adobe InDesign with its Data Merge panel is the most common starting point, often supplemented with custom scripts. For more complex campaigns, specialist tools like XMPie or PlanetPress integrate directly with InDesign’s document structure and offer more robust data logic, conditional rules, and preflight checking across thousands of records.

    Is variable data printing GDPR compliant in the UK?

    VDP campaigns using personal data must comply with UK GDPR and the Privacy and Electronic Communications Regulations. This means having a lawful basis for processing, honouring opt-outs, and handling data securely throughout the workflow. The ICO publishes specific direct marketing guidance that covers the key requirements for UK print campaigns.

    How much does a variable data printing campaign cost in the UK?

    Cost per piece typically runs between £1.50 and £5 depending on format, paper stock, personalisation complexity, and run length. Shorter runs and more complex personalisation push the cost up, but this needs to be weighed against response rates, which Royal Mail’s research consistently places at 3-5% for quality direct mail compared to under 1% for email in saturated categories.

  • Building a Design Token Pipeline With Style Dictionary: A UK Agency’s Practical Walkthrough

    Building a Design Token Pipeline With Style Dictionary: A UK Agency’s Practical Walkthrough

    Managing brand tokens across six client accounts simultaneously is, to put it plainly, a nightmare without the right tooling. Colours drift between Figma files and code, spacing scales get hard-coded into components by a developer who never saw the original spec, and then a rebrand lands and you’re hunting through three separate codebases trying to find every instance of #1A73E8. I’ve been there. Most UK agency frontend teams have. The fix, as of 2026, is a properly configured Style Dictionary pipeline, and this walkthrough covers exactly how to set one up in a way that actually survives contact with real client work.

    Developer building a Style Dictionary design token pipeline at a dual-monitor desk setup
    Photo by Daniil Komov on Pexels

    What Style Dictionary actually is (and why it’s not just a JSON file)

    Style Dictionary, built by Amazon and maintained as an open-source project, is a build system that takes your design tokens, defined as structured JSON or JavaScript objects, and transforms them into whatever output format a given platform needs. That means CSS custom properties for your web builds, Swift variables for an iOS team, XML for Android, Sass maps if your project is still on that, and so on. All from a single source of truth.

    The critical word there is transform. Style Dictionary’s real power isn’t storage, it’s the transform pipeline. You define what your tokens mean at an abstract level, then the tool handles the mechanical conversion to whatever format a developer, app team, or platform actually consumes. For a UK agency juggling, say, a fintech rebrand alongside a heritage retail brand and a B2B SaaS product, this is the difference between a design system that scales and one that quietly collapses under the weight of one-off overrides.

    Structuring your token files for multi-client agency work

    The folder structure is where most teams go wrong out of the gate. The temptation is one flat JSON file per client. Resist that.

    A structure I’ve settled on, after several iterations across agency projects, looks like this:

    tokens/
      global/
        color.json
        spacing.json
        typography.json
      clients/
        acme-corp/
          color.json
          brand.json
        northfield-retail/
          color.json
          brand.json
    config.js

    The global layer holds your primitive tokens, raw values like blue-500: #2563EB or space-4: 16px, that have no semantic meaning yet. Client folders hold semantic tokens that reference those primitives: color.brand.primary: {value: "{color.blue-500}"}. This layering means that when Acme Corp decides their primary colour is now teal, you change one line in one file. Nothing downstream breaks unless you want it to.

    Style Dictionary’s reference syntax, the curly-brace notation, handles that aliasing natively. It resolves chains of references, so button.background can point to color.brand.primary which points to color.blue-500, and the final build output will resolve all the way down to the hex value. Tidy.

    Screen showing a Style Dictionary design token colour system with semantic naming
    Photo by cottonbro studio on Pexels

    Configuring the build for Figma handoff and CSS output

    The config.js file is where you wire everything together. Here’s a stripped-down but real example for a web-first client project:

    module.exports = {
      source: [
        'tokens/global/**/*.json',
        'tokens/clients/acme-corp/**/*.json'
      ],
      platforms: {
        css: {
          transformGroup: 'css',
          prefix: 'acme',
          buildPath: 'dist/acme-corp/',
          files: [{
            destination: 'tokens.css',
            format: 'css/variables'
          }]
        }
      }
    };

    Running style-dictionary build against this spits out a CSS file full of custom properties prefixed with --acme-, which you then import into your component library or bundle. Dead simple on the surface, but that prefix is crucial in an agency context because you can import multiple clients’ token files in a demo or shared environment without collisions.

    For Figma specifically, the handoff story has improved considerably in 2026. The Figma Tokens plugin and its successor integrations can read from a GitHub-hosted JSON file, meaning your single source of truth in the repo stays synchronised with what designers see in Figma. When a designer updates a spacing value in Figma’s token panel, a pull request is opened. When a developer merges it, the CSS rebuild runs. That’s the loop you want. I’d strongly recommend reading up on the current state of Figma’s Dev Mode before setting this up, because how your tokens surface in Dev Mode inspects has changed meaningfully this year.

    Custom transforms for UK-specific needs

    Out of the box, Style Dictionary’s CSS transform group handles most scenarios. But UK agency work throws up a few edge cases worth building custom transforms for.

    Fluid typography is a common one. If you’re using clamp() values for your type scale (which you should be, if you aren’t already), you’ll want those as computed strings rather than raw pixel values. You can register a custom transform that takes a min, max, and viewport range from a token’s attributes and outputs a proper clamp() string. Something like:

    StyleDictionary.registerTransform({
      name: 'size/fluid',
      type: 'value',
      matcher: token => token.attributes.fluid,
      transformer: token => {
        const { min, max, minVw, maxVw } = token.original.attributes;
        return `clamp(${min}px, calc(${min}px + (${max - min}) * ((100vw - ${minVw}px) / (${maxVw - minVw}))), ${max}px)`;
      }
    });

    That’s one registration, and every fluid type token across every client build uses it consistently. This kind of thing compounds nicely, especially once you have four or five custom transforms covering your agency’s standard patterns.

    Colour token naming is another area where getting the structure right early pays off enormously. If you’ve read our piece on colour token naming and contrast grids, you’ll know the semantic layer matters more than the primitive layer for day-to-day developer use. Style Dictionary makes enforcing that semantic naming convention in your JSON schema straightforward, because the dot-notation in your token paths maps directly to CSS custom property names.

    Running this across multiple clients without losing your mind

    The multi-client setup needs a build script, not just a single Style Dictionary config. I use a small Node script that iterates over a clients/ directory, dynamically generates a config for each client by merging global tokens with client-specific overrides, and runs a build. The output is a dist/ folder with one subdirectory per client, each containing their own token CSS file, ready to be consumed by whatever frontend stack that project runs on.

    This scales. I’ve run this against eight simultaneous client configs in under four seconds on a modest laptop. For a UK agency doing quarterly brand refreshes and annual rebrands, that turnaround matters.

    Version control is non-negotiable here. Every token change goes through Git, with a meaningful commit message, so you have a full audit trail of when a colour changed and why. This is useful not just for debugging but for client conversations: “your brand primary changed on 14 March, here’s the commit.” Clients, especially those in regulated industries, appreciate that level of traceability.

    For a sense of the broader landscape that UK product teams are operating in, the government accessibility requirements for websites and apps are worth keeping in your peripheral vision, particularly when your token system needs to account for WCAG contrast compliance across multiple brand palettes.

    Connecting your token system to the wider product workflow

    A token pipeline doesn’t live in isolation. It touches your component library, your Storybook instance, your CI build, and your Figma workflow. Getting those connections right is as important as the Style Dictionary config itself.

    One pattern I’ve seen work well at UK agencies is hooking the Style Dictionary build into a GitHub Action that fires on any change to the tokens/ directory. The action builds the tokens, commits the updated CSS to a dist branch, and optionally publishes to npm if the component library consumes tokens as a package. The whole thing runs in under thirty seconds. Developers get updated tokens without touching the config themselves, and designers don’t need to manually sync anything.

    If your agency also runs paid media for clients alongside the design work, the same discipline around structured, auditable systems applies. Agencies like dijitul Marketing bring that kind of systematic rigour to campaign management, which is a useful parallel: structured inputs, predictable outputs, traceable decisions.

    The token system also connects naturally to your test data story. If you’re prototyping UI states with realistic data, as covered in our walkthrough on using Faker.js and seed scripts to replace lorem ipsum, having your design tokens already resolved means your component demos use real brand colours and spacing, not placeholder guesses. The whole system starts to feel coherent rather than cobbled together.

    The things that will still trip you up

    A few honest gotchas, because no walkthrough should pretend this is frictionless.

    First, circular references. If token A references token B which references token A, Style Dictionary will throw an error at build time. That’s the right behaviour, but it means you need to be disciplined about your token graph. Primitives never reference semantics. Semantics reference primitives. Components reference semantics. One direction only.

    Second, token naming conventions need team buy-in. If one designer names something color.ui.button.primary and another names it button.primary.color, your JSON will become incoherent fast. Document your naming convention in your repo’s README on day one. Enforce it in code review.

    Third, the Figma plugin ecosystem for token sync is still more fragmented than it should be in 2026. Test your chosen plugin against a real client file before committing to it as your agency standard. Some plugins handle nested token groups cleanly; others flatten everything and lose the hierarchy that Style Dictionary depends on.

    None of these are deal-breakers. They’re friction points that good setup decisions eliminate early. Get the folder structure right, document the naming convention, and the pipeline genuinely does become the boring, reliable infrastructure it should be.

    Frequently Asked Questions

    What is Style Dictionary and how does it work with design tokens?

    Style Dictionary is an open-source build system that takes design tokens defined as JSON and transforms them into platform-specific outputs, such as CSS custom properties, Swift variables, or Sass maps. You define tokens once and the tool handles the conversion, meaning one source of truth serves every platform your product ships on.

    How do I manage multiple client brand systems with a single Style Dictionary setup?

    The recommended approach is a layered folder structure: a global layer for primitive tokens (raw colour values, spacing scales) and per-client folders for semantic tokens that reference those primitives. A build script iterates over client directories and generates a separate token output for each, so there’s no collision between brand systems.

    Can Style Dictionary output tokens that Figma can read?

    Yes. Style Dictionary’s JSON output can be consumed by Figma token plugins, with several integrations supporting a GitHub-hosted JSON file as the sync source. When a designer updates a token in Figma, the change opens a pull request; when merged, the Style Dictionary build runs and updates the CSS. It’s not entirely frictionless yet, but it works reliably for most agency setups.

  • Designing Invoicing and Payment Interfaces for UK Freelancers: The VAT, MTD, and HMRC Details That Actually Matter

    Designing Invoicing and Payment Interfaces for UK Freelancers: The VAT, MTD, and HMRC Details That Actually Matter

    There is a surprisingly narrow gap between an invoicing tool that genuinely helps a UK self-employed person and one that technically works but quietly drives them mad every time they raise a bill. I have spent a fair amount of time poking around tools like FreeAgent, QuickBooks, Xero, and Zoho Invoice from a design perspective rather than an accountant’s, and what I keep finding is the same cluster of UI decisions made by people who either don’t understand how UK freelancers actually bill, or who designed for a generic global user and bolted on a ” UK mode” as an afterthought. The details really do matter here, and invoicing app design for UK freelancers, specifically around MTD, is one of those domains where a handful of small interface choices either build or completely destroy a user’s trust.

    Freelancer reviewing invoicing app design for UK MTD compliance on laptop
    Photo by cottonbro studio on Pexels

    Why invoicing is a harder UX problem than it looks

    On the surface, an invoice is just a document with some numbers on it. The complexity creeps in the moment you layer on the UK-specific regulatory context. A self-employed person in the UK might be VAT-registered or not. If they are, they need to apply the correct rate (standard 20%, reduced 5%, or zero-rated), show the VAT amount as a separate line, display their VAT registration number on the invoice face, and generate a quarterly summary that feeds into a Making Tax Digital-compatible submission to HMRC. If they are not VAT-registered, none of that applies, but the interface still has to handle the state gracefully rather than just hiding fields and leaving a confusing gap in the layout.

    MTD for Income Tax Self Assessment (ITSA) is rolling out to sole traders and landlords with income above £50,000 from April 2026, dropping to £30,000 from April 2027, according to HMRC’s own guidance on Making Tax Digital. That means a significant chunk of self-employed users are going to need their invoicing tool to connect directly to HMRC’s API infrastructure, or at least export data in a format a bridging tool can consume. If the app’s data model doesn’t cleanly separate gross income, allowable expenses, and tax by quarter, the UI will become a mess of manual workarounds.

    The VAT calculation problem is mostly a UI sequencing problem

    I’d argue that most VAT errors in invoicing UIs are not calculation errors at all. They are sequencing errors. The app asks for a line item amount, and it is unclear whether that amount is exclusive or inclusive of VAT. Some tools default to exclusive (the accountant-friendly default) without making that obvious to a user who typed in a round number expecting it to be what the client pays. Others toggle the behaviour per line item but hide the toggle in a settings panel three levels deep.

    The cleanest pattern I have seen is a persistent, visible label directly adjacent to every price input: a small toggle that reads “ex. VAT” or “inc. VAT”, styled as a segmented control rather than buried in a dropdown. The gross and net amounts then update live beneath the input. This sounds obvious. Very few tools actually do it. FreeAgent gets close, though it tends to assume ex. VAT at all times, which trips up newer freelancers who quote inclusive prices to clients.

    Partial exemption is where things get genuinely gnarly. A designer who also licenses stock assets might have a mix of standard-rated and exempt supplies on the same invoice. The interface needs to handle mixed-rate line items without requiring the user to split the invoice manually. This is rare enough that most tools don’t bother, but for micro-agencies it comes up constantly. If you’re designing a micro-SaaS product aimed at solo UK developers, this is exactly the kind of edge case that separates a tool worth paying for from one people drop after two months.

    Payment status states: the UI gets lazy here every time

    An invoice is not a static document. It passes through multiple states over its lifetime, and a well-designed tool treats each state as a distinct UI moment with distinct affordances. The states a UK freelancer actually cares about are broadly: draft, sent, viewed (if read receipts are available), partially paid, overdue, paid, and written off. Most apps handle draft and paid. The middle ground is where the design falls apart.

    “Overdue” is particularly underserved. An invoice becomes overdue the moment it passes its payment terms date. The correct UI response is an immediate, ambient status indicator on the invoice list view, not a buried orange badge that only appears when you open the individual record. The list view should surface: how many days overdue, the outstanding amount, and a one-click chase action that generates a polite reminder email using the client’s name pulled from the contact record. Xero’s invoice list is reasonable here. Zoho Invoice used to be terrible at this but improved around late 2024.

    Partial payment is handled badly by almost everyone. The UI typically shows a payment received, subtracts it from the total, and leaves the remaining balance visible on the invoice record. What it rarely does is update the invoice status label to something meaningful like “Part paid” or show a visual progress bar on the payment. A bar showing £600 received against a £1,200 invoice is immediately scannable. A number buried in a summary table is not. This is a basic data visualisation principle that applies just as much to invoicing as it does to analytics dashboards.

    There’s also the question of what happens after payment is marked. Most tools do nothing. A smart tool archives the invoice, updates the client’s payment history, and optionally prompts the user to log any bank transfer fees as an expense, keeping the MTD records clean. That last step is the kind of thought that shows real understanding of the workflow, not just the document format.

    MTD compliance in the UI: what it actually requires you to show

    Making Tax Digital for ITSA requires digital records of income and expenses, quarterly submissions, and a final declaration. For an invoicing tool, the UI implication is that every invoice needs to be classifiable by tax year and quarter at the point of creation, not retroactively. Some tools make you tag invoices manually by quarter; this is a design failure. The quarter should be inferred automatically from the invoice date and the user’s accounting period settings, with a visible indicator on the invoice record confirming which submission it will roll into.

    The quarterly summary view is where most tools currently fail their UK users most visibly. What a freelancer needs to see, in plain language, is their total taxable income for the quarter, their allowable expenses, and the net figure that will be submitted to HMRC. Many apps show these figures somewhere, but they are scattered across separate reports rather than surfaced as a single pre-submission dashboard. The GOV.UK Design System approach of task-based progress states would work beautifully here: a checklist that shows which invoices are categorised, which expenses are logged, and whether the quarter is ready to submit. Incidentally, there is a lot the public sector has figured out here that the private sector still ignores, which I wrote about separately in a piece on what the GOV.UK Design System gets right that most private sector UI libraries get wrong.

    The submission itself should be a single action with a clear confirmation state. Currently, most tools that support MTD direct submission show a modal, ask for confirmation, fire the API call, and then return the user to the dashboard with no persistent record of what was submitted or when. The correct pattern is a submission receipt view with a timestamp, a reference number from HMRC, and a link to download the submitted data as a PDF. Audit trails matter for compliance and they matter for the user’s peace of mind.

    Small details that builders consistently miss

    A few things I would add to any design spec for this kind of tool. First, the invoice number sequence. UK freelancers often have clients who require invoices to follow a specific format, and the ability to customise the prefix and starting number is non-negotiable. But the UI should also warn users if they are about to create a gap in the sequence, because a missing invoice number can flag a VAT audit.

    Second, currency handling. A UK freelancer who invoices in GBP but occasionally bills an EU client in euros needs the tool to record the sterling equivalent at the exchange rate on the invoice date, for MTD record-keeping purposes. This is largely ignored by mid-market tools. If you’re thinking about building something in this space and you’ve looked at how Figma’s Dev Mode handles complex state management between design and code, the principle is similar: the source of truth needs to be unambiguous even when the display layer shows a different unit.

    Third, the statement of account view. Many UK clients request a statement rather than individual invoices when settling multiple bills at once. This is a separate document type with its own UI requirements: it lists all outstanding invoices for a given client, with dates, amounts, and running balances. Most invoicing tools treat this as a secondary feature or don’t have it at all. For a freelancer managing ten or more active clients, it’s essential.

    The invoicing interface is genuinely one of the most legally consequential UIs a self-employed person uses. Getting it wrong is not just a UX annoyance; it can mean a failed VAT return or a compliance gap in their MTD records. That’s reason enough to design it properly from the start, rather than treating the UK regulatory layer as a localisation task someone can bolt on in a sprint.

  • The Case for Designing With Real Data From the Start: How UK Product Teams Are Using Faker.js and Seed Scripts to Kill Lorem Ipsum

    The Case for Designing With Real Data From the Start: How UK Product Teams Are Using Faker.js and Seed Scripts to Kill Lorem Ipsum

    There is a specific kind of design review horror that every UK product designer eventually experiences. The prototype looks immaculate. The components are tight, the spacing is perfect, and the typography sings. Then someone asks: “What happens when the user’s surname is Featherstonehaugh?” Or: “Our biggest client has a 47-character company name.” The room goes quiet. The designer opens Figma and starts dragging a text box wider. The dream is over.

    That scenario is almost entirely caused by one bad habit: designing with placeholder content. Lorem ipsum is comfortable. It fills space without asking difficult questions. But it lies to everyone in the room, and I’d argue it’s one of the most underrated sources of production bugs and last-minute design rework in UK product teams today. Replacing it with realistic test data UI design UK practice isn’t a nice-to-have; it’s a discipline that changes the quality of every design review you run.

    Product designer reviewing realistic test data UI design UK dashboard on a large monitor
    Photo by SHVETS production on Pexels

    Why lorem ipsum is a design smell

    Placeholder text masks problems that only emerge with real content. A navigation label that reads “Lorem” fits neatly. “Accessibility Settings” might not. A dashboard card with “Lorem ipsum dolor” as the description looks fine at 16px. “You have 3 outstanding invoices totalling £4,280.00 (VAT inclusive)” at the same size might wrap awkwardly, break a flex container, or push a CTA button off-screen entirely.

    These aren’t edge cases. They’re the norm for UK products that serve real British users with British addresses, postcodes, phone numbers, and names drawn from an extraordinarily varied pool. The Office for National Statistics publishes population data that illustrates just how linguistically diverse the UK is. If your app serves the public, your test data needs to reflect that diversity or you’ll ship interfaces that break on perfectly normal inputs.

    The fix isn’t complicated, but it does require a shift in how teams think about the design-to-development handoff. And Faker.js with the en_GB locale is the cleanest place to start.

    What Faker.js en_GB actually gives you

    Faker.js is a widely used JavaScript library for generating synthetic but structurally accurate fake data. The en_GB locale setting is the part most UK teams skip, and it matters enormously. Without it, you get American-formatted phone numbers, US-style zip codes, and first names weighted heavily towards an American demographic distribution. With en_GB, you get UK mobile numbers in the 07xxx xxxxxx format, British postcodes like SW1A 1AA or M1 1AE, and names that actually reflect the British population: Priya, Mohammed, Cillian, Aoife alongside James, Sarah, and David.

    Here’s the kind of seed script I’d use to generate a realistic dataset for a UK SaaS dashboard review:

    import { faker } from '@faker-js/faker/locale/en_GB';
    
    const generateUser = () => ({
      id: faker.string.uuid(),
      name: `${faker.person.firstName()} ${faker.person.lastName()}`,
      email: faker.internet.email(),
      phone: faker.phone.number(),
      postcode: faker.location.zipCode(),
      company: faker.company.name(),
      plan: faker.helpers.arrayElement(['Starter', 'Growth', 'Enterprise']),
      invoiceTotal: faker.finance.amount({ min: 50, max: 12000, dec: 2, symbol: '£' }),
      joinedAt: faker.date.past({ years: 3 }).toLocaleDateString('en-GB'),
    });
    
    const users = Array.from({ length: 50 }, generateUser);
    console.log(JSON.stringify(users, null, 2));

    Run that once and you have 50 structurally honest user records. Drop them into your design tool via a JSON plugin, or pipe them into a Storybook story, and suddenly your design review is testing something real.

    How realistic data changes design reviews

    I’ve sat in enough design crits to know that lorem ipsum reviews have a particular rhythm: everyone nods at the aesthetics and nobody catches the layout bugs. Swap in real data and the conversation changes completely. People start asking the right questions immediately.

    Long company names break table rows. Very short names (“Jo”, “Ed”) create awkward avatar initials. Financial figures with varying digit counts expose alignment issues in data tables. British postcodes have variable lengths (“E1 6RF” versus “SW1A 2AA”) that will absolutely break a fixed-width input if nobody tested it. Dates formatted as en-GB (“21 April 2026”) behave differently from ISO strings in ways that affect column widths.

    This connects directly to a broader problem I’ve written about with British SaaS dashboards failing at data visualisation: the visual layer only tells you something useful if the data underneath it is honest. A chart seeded with placeholder values of similar magnitude will look balanced. Real financial data with outliers will expose whether your Y-axis scaling is any good.

    Integrating seed scripts into the design workflow

    The practical question is where this data actually lives in a team’s process. There are a few patterns worth knowing.

    Figma + JSON plugins: Tools like Figma’s own “Content Reel” or the “JSON to Figma” community plugin let you paste a JSON array and populate component instances automatically. Generate your Faker data, export it, load it in. Takes about three minutes once the script exists.

    Storybook stories with seeded data: For component-level work, writing Storybook stories that import from a shared seed script is even more powerful. Every developer on the team sees the same realistic data when they open the component browser. If you’re doing any work that touches solo micro-SaaS UI development, this is a genuinely weekend-implementable improvement to your workflow.

    Shared seed fixtures in the repo: The most mature version of this is a /fixtures directory in the codebase with a set of deterministic seed scripts (using a fixed random seed so the data is reproducible). Designers reference the same fixture files that QA engineers use. Suddenly “the data in the mockup” and “the data in the test environment” are the same thing, which eliminates an entire category of “it looked fine in Figma” conversations.

    The locale details that actually matter for UK products

    Beyond names and postcodes, there are some locale-specific data patterns that UK products get wrong constantly:

    Phone numbers: UK mobiles start with 07. UK landlines vary by region: 020 for London, 0161 for Manchester, 0131 for Edinburgh. If your input field only fits 11 digits with no space formatting, you need to know that before you ship.

    VAT numbers: UK VAT registration numbers follow the format GB followed by 9 digits. Faker’s en_GB locale doesn’t generate these natively, but a simple custom helper wrapping faker.string.numeric(9) with the GB prefix gets you there.

    Bank sort codes and account numbers: The UK uses 6-digit sort codes (formatted as XX-XX-XX) and 8-digit account numbers. Again, Faker doesn’t generate these by default, but they’re trivial to construct and essential if you’re building any fintech-adjacent interface.

    Names with apostrophes and hyphens: O’Brien, Al-Hassan, Lloyd-Jones. If your database schema or your UI component hasn’t been tested with these, it probably breaks somewhere. Seed your data with a handful of deliberately awkward names and find out before a real user does.

    All of this feeds into why teams doing genuinely differentiated UK B2B SaaS product design tend to have stronger QA cultures too. The design and development disciplines start to blur productively when the artefacts they work with share the same data reality.

    A note on edge cases as first-class design concerns

    One thing I’d push back on is the framing of long names or unusual characters as “edge cases”. In a UK product with any meaningful user base, they’re just… cases. The ONS data on name diversity, the variation in UK address formats across England, Scotland, Wales, and Northern Ireland (where some postcodes behave differently), and the variety of business entity types (Ltd, LLP, PLC, sole trader) all mean that the surface area of “normal” is wider than most teams design for.

    Seed scripts with realistic test data are the mechanism that makes this visible early. A design review where someone spots that the table breaks on a Welsh business name is infinitely cheaper than a support ticket from a real user in Llanfairpwllgwyngyll.

    The tooling is lightweight, the setup time is minimal, and the improvement to design review quality is immediate. Lorem ipsum had a good run. It’s time to retire it.

  • Micro-SaaS Product Design on a Shoestring: How UK Solo Developers Are Shipping Polished UIs Without a Designer

    Micro-SaaS Product Design on a Shoestring: How UK Solo Developers Are Shipping Polished UIs Without a Designer

    There is a very specific kind of despair that hits at around 11pm on a Tuesday, when your micro-SaaS is functionally complete, your Stripe integration works, your auth is solid, and then you open the browser and look at the interface you have built. It looks like a university coursework submission from 2014. This is the micro-SaaS UI design problem, and if you are a UK solo developer, it is probably the gap between shipping and actually getting paying customers.

    I have been watching this space closely for the past couple of years, and what has genuinely changed is that the tooling has caught up. The combination of mature component libraries, properly designed token systems, and headless UI primitives means a solo developer who is willing to spend a focused weekend can produce an interface that looks completely credible. Not just “passable”. Actually good. Here is how UK indie developers are doing it in 2026.

    UK solo developer working on micro-SaaS UI design at a desk late at night
    Photo by Daniil Komov on Pexels

    Why most indie developer UIs fail before the first demo

    The problem is almost never technical. Solo developers who can ship a multi-tenant backend with row-level security in Supabase are not struggling because UI is hard. They are struggling because good UI design requires a set of decisions that compound: spacing scales, colour relationships, type hierarchies, interaction states. Miss one layer and the whole thing looks wrong in ways that are hard to diagnose.

    The instinct is to grab a component library and bolt it on. That works, up to a point. But unstyled Tailwind with default shadcn/ui components looks exactly like unstyled Tailwind with default shadcn/ui components. Every micro-SaaS on Product Hunt right now has the same slightly-too-grey sidebar, the same Inter font at 14px, the same ghost buttons that vanish on light backgrounds. The trick is not just picking a library. It is understanding the layer underneath it: design tokens.

    Design tokens: the thing most solo developers skip entirely

    A design token is just a named variable for a design decision. --color-surface-primary instead of #ffffff. --space-4 instead of 16px. That sounds trivial until you have to change your brand colour across 47 components, or you need to add a dark mode, or your first enterprise customer asks if they can have a white-labelled version with their own colours.

    The W3C Design Tokens Community Group has been working on a standardised token format, and tools like Style Dictionary (maintained by Amazon) have made it possible to define tokens once and compile them to CSS custom properties, Tailwind config, and even iOS/Android values simultaneously. For a solo developer, this is huge. You define your spacing, colour, and typography decisions in one JSON file and let the toolchain propagate them everywhere.

    I would recommend starting with a minimal token set: five or six semantic colour roles (surface, on-surface, primary, on-primary, border, error), a spacing scale based on a 4px base unit, and two or three type sizes. That is genuinely enough to make an interface feel coherent. Resist the urge to over-engineer it before you have paying customers. If you are interested in how professional UK design teams handle token naming at scale, the contrast grids and colour token naming patterns being adopted by UK product teams are worth reading before you set up your own system.

    Design token system and component library used for micro-SaaS UI design on a monitor
    Photo by Ann H on Pexels

    The component libraries UK indie developers are actually shipping with

    Here is what I am seeing in the wild, from conversations in the Indie Hackers UK community and from poking around the public repos of recently-launched British micro-SaaS products.

    shadcn/ui with Radix primitives

    This is the dominant stack right now, and for good reason. shadcn/ui is not a traditional component library you install as a dependency. You copy the components directly into your project, which means you own the code. Radix UI provides the accessible, unstyled primitives underneath: dialogs, dropdowns, tooltips, all with keyboard navigation and ARIA attributes handled correctly. You get the accessibility baseline for free and the styling is entirely yours to control via Tailwind and your token layer.

    The downside is that the default aesthetic is quite neutral. You have to actually make design decisions on top of it, which is the point, but it means you cannot just install it and call it done.

    Mantine

    Mantine is the alternative I keep recommending to solo developers who want more out of the box. It has 120-plus components, a built-in theming system that maps closely to design tokens, and genuinely good defaults. The dark mode support is excellent. It is also well-maintained, with the Mantine team pushing consistent releases. The trade-off is bundle size and the fact that you are more constrained by the library’s design decisions. For a solo developer shipping fast, that constraint is often a feature, not a bug.

    Headless UI (from Tailwind Labs)

    Headless UI is narrower in scope than the others but worth mentioning for React and Vue developers already deep in the Tailwind ecosystem. It covers the components where behaviour is the hard part: listboxes, comboboxes, disclosure panels, transitions. If you are building a data-heavy SaaS with custom filtering UI, it handles the interaction logic cleanly.

    Making it look less like a template

    This is where the gap between “functional UI” and “credible UI” actually lives, and it is almost entirely about typography and whitespace. I cannot stress this enough. The single highest-return intervention a solo developer can make is to slow down and actually think about their type scale.

    Use a proper modular scale. Tools like Utopia.fyi let you define fluid type and space scales in CSS that interpolate between a minimum and maximum viewport width. Pair this with a good font: Geist (from Vercel, free) is excellent for product interfaces. Inter is fine but it is everywhere. Instrument Sans has a slightly warmer personality that works well for B2C SaaS. If you want to dig into the open-source font pairings that UK designers are currently using to stand out, the combinations worth actually using in 2026 cover this in proper depth.

    Beyond typography, the most common UI failure I see in indie products is insufficient spacing. Developers add padding that feels “enough” but does not give elements room to breathe. Double your padding values everywhere, then pull back by 20 per cent. You will almost always end up in a better place.

    Handling the conversion layer: landing pages and onboarding

    The app interface is only half the problem. For micro-SaaS, the marketing site and the first-run onboarding experience are where most revenue is won or lost. UK solo developers are increasingly treating these as separate design problems with different tooling.

    For landing pages, Astro with a component library like Flowbite Blocks or a purchased Tailwind UI template is a common approach. The layout decisions that actually differentiate UK B2B SaaS homepages are worth reviewing before you settle on a structure, because the default hero-features-pricing layout is doing no one any favours.

    For onboarding, the principle is simpler: show value as fast as possible, and do not ask for information you do not need yet. Progressive disclosure is your friend. Build the empty states deliberately. An empty dashboard that says “No data yet” is a conversion killer. An empty state that shows a greyed-out example with a clear single action is not.

    Getting eyes on your work early

    One thing that consistently separates the UK indie developers who ship polished products from those who do not is that they get external feedback before they think they are ready. The GOV.UK Service Standard has a principle around this: show the thing, not the idea. It applies equally well to commercial micro-SaaS.

    Post to the Indie Hackers UK Slack, share on X (Twitter), get a friend who is not a developer to try the onboarding. When I have spoken to solo developers who built products that actually convert, virtually all of them describe a moment where someone pointed out something completely obvious that they had been blind to because they were too close to it.

    For getting distribution sorted once you have a product worth promoting, tools like LinkPress are the kind of thing solo developers should be aware of as part of their broader go-to-market approach.

    The GOV.UK Service Manual design guidance is also genuinely useful reading even for commercial products. The thinking behind how they approach interaction design and user research is applicable well beyond public sector work.

    A realistic timeline for a solo developer

    Here is my honest estimate of what is achievable. Set up your token system and base Tailwind config: three to four hours. Implement shadcn/ui or Mantine and style it to your tokens: one full day. Land a coherent marketing page: another day. That is a weekend, realistically a long one. What you ship at the end of that will not be award-winning, but it will be clean, consistent, and credible enough to convert genuinely interested users.

    The mistake is treating design as something that happens at the end. Wire it into your development workflow from day one. Define your tokens before you write your first component. Pick your library before you scaffold your first page. The compounding benefit is enormous.

    Micro-SaaS UI design is solvable for solo developers. The tooling exists. The open-source resources exist. What it requires is treating design decisions as engineering decisions: deliberate, early, and documented.

    Frequently Asked Questions

    What is the best component library for a UK solo developer building a micro-SaaS in 2026?

    shadcn/ui with Radix primitives is the most popular choice because you own the code and have full styling control via Tailwind. Mantine is a strong alternative if you want more pre-built components and a built-in theming system without as many configuration decisions upfront.

    Do I need to understand design tokens to ship a polished UI?

    Not deeply, but you need the basic concept. At minimum, define your semantic colour roles and spacing scale as CSS custom properties before you write a single component. This single step will make your entire interface more consistent and saves significant time later when you need dark mode or white-labelling.

    How long does it realistically take to go from rough UI to polished interface?

    For a focused solo developer working with a good component library and a pre-defined token system, a weekend (roughly 12 to 16 hours of deliberate work) is enough to produce a credible, consistent interface for a small micro-SaaS product. Marketing page included.

    Is Tailwind CSS enough on its own for a micro-SaaS UI?

    Tailwind alone is a low-level utility layer, not a design system. Without a component library on top and a deliberate set of design tokens underneath, you will end up with an inconsistent interface that requires a lot of duplicated decision-making. Combine it with shadcn/ui or Mantine for best results.

    How do UK indie developers handle accessibility in their UIs without a specialist?

    Radix UI primitives and Mantine both handle the most common accessibility requirements out of the box: keyboard navigation, ARIA attributes, focus management. You still need to check colour contrast against WCAG AA standards, which you can do with free tools like the WebAIM Contrast Checker, but the structural accessibility is largely handled by the library.

  • Why British B2B SaaS Homepages All Look the Same in 2026, and the Layout Decisions That Would Actually Differentiate Them

    Why British B2B SaaS Homepages All Look the Same in 2026, and the Layout Decisions That Would Actually Differentiate Them

    Spend ten minutes clicking through British B2B SaaS homepages and a peculiar vertigo sets in. There’s the centred headline in Inter or Plus Jakarta Sans, somewhere between 52px and 72px, promising to “streamline your workflow”. Below it, three trust badges from G2 or Capterra. Then a feature grid: three or four cards, each with a small icon, a bold subtitle, and two sentences of copy that could have been written by anyone for anything. If you’re lucky, there’s a dashboard mockup floated at an angle, casting a soft drop shadow over a gradient background. I’ve audited close to forty of these sites in the past few months and I can tell you: B2B SaaS homepage design UK 2026 has a serious sameness problem.

    This isn’t a style complaint. It’s a conversion problem. When every competitor looks identical, you’re not competing on design at all. You’re competing solely on whichever ad someone saw last, or which sales rep rang first. The homepage, the one page almost every buyer visits before they sign up for a demo, has become a genre with its own rigid conventions, and those conventions are actively harming differentiation.

    Designer reviewing B2B SaaS homepage design UK 2026 examples on monitor
    Photo by Hanna Pad on Pexels

    How the formula became universal

    There’s an obvious origin story. A handful of high-growth US SaaS companies in the mid-2010s hit on a pattern that converted well for them: big headline, social proof, feature breakdown, CTA. Webflow and Framer then packaged those patterns into templates. Growth marketers A/B tested their way to similar conclusions across dozens of markets. Design agencies, rightly trying to reduce client risk, defaulted to what had “worked before”. And so the formula calcified.

    The trust-badge strip is the clearest tell. It exists because third-party validation reduces anxiety at the top of the funnel. That’s a legitimate goal. But when the strip contains the same four logos (G2, Capterra, Trustpilot, and one enterprise client badge) in the same greyscale treatment, directly beneath a headline that also matches your competitor’s, you’ve created something that functions as camouflage rather than signal. Buyers scroll past trust badges now. They’ve been conditioned to.

    The feature grid below is even more blunt. Three columns. Icon. Bold title. Short paragraph. It answers “what does it do” efficiently, but it says almost nothing about why this product specifically. Every grid implies that features are comparable and interchangeable. Which, for a category leader, is a terrible frame to establish on your own homepage.

    What a visual audit of UK SaaS homepages actually reveals

    I ran a rough audit across thirty-five UK-headquartered B2B SaaS products spanning HR tech, fintech infrastructure, legal tech, and property management software. The findings were depressingly consistent. Ninety-one per cent led with a centred headline and subheading. Eighty-six per cent had a trust-badge strip within the first two screen-heights. Seventy-eight per cent used a three or four-column feature grid. Not a single one opened with a full-bleed editorial-style image or a typographic treatment that looked genuinely distinctive.

    The typographic choices compound the problem. Inter is everywhere, it’s a superb typeface, which is exactly why it no longer signals anything except “we used the default”. The semantic colour systems that UK design teams are building internally rarely make it to the public marketing site, where someone has apparently decided that navy, white, and one “brand accent” colour covers everything. The result is a palette that’s legible but forgettable.

    Motion makes things worse, not better. Scroll-triggered fade-ins have become so ubiquitous that they’ve become invisible. A feature section that cascades in with staggered opacity animations used to feel polished; now it just feels like everyone watched the same Webflow tutorial. I’d argue that a static, confidently composed page with zero scroll animations would feel more distinctive in 2026 than a page with tasteful micro-interactions, which tells you something about how far this has gone.

    Layout decisions that would actually differentiate

    So what does a genuinely different B2B SaaS homepage look like? A few directions I’d push clients towards:

    Left-aligned, editorial-weight typographic heroes

    Centred heroes exist because they feel balanced and safe. Left-aligned editorial layouts feel like a magazine or a newspaper: authoritative, confident, and legible in a way that centred copy isn’t. Set your headline at 96px in a geometric serif, something like Fraunces or a properly licensed display face, flush left, with the CTA anchored at the baseline. The visual tension between a heavy typographic block and whitespace on the right is itself communicative. It says the company has opinions.

    Replace the trust strip with a single, specific proof point

    Pick one number that’s impossible to fake and hard to ignore. Not “used by 500+ companies” but “reduced supplier invoice processing time by 34% for Farrow & Ball’s procurement team in Q3 2025”. Put it in 48px type, cite it properly, and link to the case study. One credible specific claim beats four anonymous badge logos. The ONS data on UK IT industry growth repeatedly shows that B2B purchase decisions are driven by evidence of ROI, not social proof signals, and specific quantified evidence converts better than generic validation.

    Narrative feature sections over grids

    Instead of three cards in a row, try an alternating two-column layout where each feature gets a full half-screen. Left column: a real screenshot or a composed illustration showing the feature in context. Right column: a short, opinionated paragraph that explains not what the feature does but what it means for the person reading. This forces copywriters to write about outcomes and forces designers to produce actual product shots rather than icon-plus-tagline placeholders. It’s slower to produce, which is probably why nobody does it, and that’s exactly the point.

    Problem-led above the fold

    Most SaaS homepages open with the solution. “Meet [Product]: the platform that does X.” Try opening with the problem instead. A single brutal sentence naming the specific pain of the specific buyer. “Your finance team is still exporting to Excel to reconcile what your SaaS stack should be doing automatically.” That kind of opener presupposes the buyer’s context rather than explaining the product’s features, which immediately creates the feeling that this company understands them. It’s a copywriting decision as much as a layout one, but it changes how the whole page is structured from the hero down.

    The dashboard mockup problem

    I need to talk about the floating dashboard. The tilted-at-25-degrees, drop-shadow-heavy, gradient-background product screenshot has become the SaaS homepage’s equivalent of a stock photo of a woman laughing at a salad. It signals “software” without showing anything. When every competitor floats the same kind of mockup, you’ve created a visual genre rather than a product demonstration.

    The alternative isn’t removing product visuals, buyers need to see what they’re buying. The alternative is context. A screenshot of your dashboard shown on an actual desk, in an actual working environment. Or a short, looping screen recording that shows a real workflow completing in eight seconds. Or a composed sequence of three moments in the user journey, captioned with the time saved at each step. Any of these is harder to produce than dropping a PNG into a Figma mockup template and tilting it. Which is, again, the point. Web performance considerations matter here too, large hero images and animated mockups are among the most common contributors to poor LCP scores on UK SaaS marketing sites.

    Typography as differentiation

    If you want your homepage to look different, the fastest lever is typeface choice. Inter, DM Sans, and Plus Jakarta Sans are all technically excellent and visually indistinct from one another at scale. Open source font pairing has matured significantly in 2026, there are genuinely interesting options available without a licensing bill. Fraunces for display, Literata for body copy, Anybody for tabular data labels. These aren’t exotic choices; they’re just slightly less default ones, and that distance from the default is what the eye catches.

    Pair unconventional typeface choices with deliberate typographic scale. Most SaaS sites use a type scale that compresses everything into a narrow range: 16px body, 24px subheadings, 52px headlines. Try an aggressive scale: 14px body, 20px subheadings, 96px display. The contrast between the display size and the body size creates a visual hierarchy that guides the eye without needing layout gimmicks.

    This isn’t about being weird for its own sake

    The goal here isn’t to build a homepage that wins design awards and fails to convert. Conversion matters. The point is that the current formula has been copied so widely that it no longer confers the conversion advantages it once did. A buyer who has visited six competitor sites in the same afternoon needs a reason to pause. Right now, most UK B2B SaaS homepages give them no such reason. The irony is that the safe, formula-driven approach feels lower risk but is genuinely higher risk, because it guarantees you look like everyone else in a market where looking like everyone else is the worst possible outcome.

    Breaking from the formula doesn’t require a brand overhaul or a six-month redesign project. It requires a clear point of view: about who the buyer is, what they’re struggling with, and why this particular product is the specific answer. That point of view should drive every layout decision, every type choice, and every piece of visual evidence on the page. When it does, the homepage stops being a genre exercise and starts being an actual argument.

    Frequently Asked Questions

    Why do so many B2B SaaS homepages look identical in 2026?

    The formula, centred hero, trust badges, feature grid, spread through shared templates on Webflow and Framer, plus agencies defaulting to “what’s worked before”. High-growth SaaS companies validated the pattern in the mid-2010s and it was copied so widely that it stopped conferring any competitive advantage.

    Does breaking the standard SaaS homepage formula hurt conversion rates?

    Not inherently. The concern is understandable, but the standard formula only converted well when it was novel. When every competitor uses it, it becomes noise rather than signal. Specific, opinionated design choices that reflect a clear understanding of the buyer tend to build more trust, not less.

    What typefaces work well for B2B SaaS homepages that want to stand out?

    Fraunces and Literata are strong open-source options that read as confident without being gimmicky. The key is pairing a distinctive display face with a clean body typeface and using an aggressive size scale, wide contrast between headline and body sizes creates hierarchy without needing layout tricks.

    Are floating dashboard mockups still effective for SaaS marketing sites?

    They’ve become so ubiquitous they’ve stopped working as differentiators. A contextual screenshot showing the product in a real working environment, or a short looping screen recording of an actual workflow, tends to communicate more about the product and feel more credible to buyers who’ve seen dozens of tilted PNG mockups.

    How important is the hero section for B2B SaaS conversion?

    Extremely. Most B2B buyers visit the homepage before booking a demo or starting a trial, so the above-the-fold section does enormous work. A problem-led opener that names a specific buyer pain tends to convert better than a product-led opener that lists features, because it immediately signals to the reader that the company understands their context.

  • Contrast Grids and Colour Token Naming: How UK Design Teams Are Finally Solving Their Semantic Colour System Problems

    Contrast Grids and Colour Token Naming: How UK Design Teams Are Finally Solving Their Semantic Colour System Problems

    Colour decisions in product design look deceptively simple until your rebrand lands, someone switches to dark mode, and your carefully chosen palette turns into a contrast disaster that fails WCAG AA at about twelve different points. I’ve watched this happen to teams who thought they had a proper colour system, only to discover they had a colour list with a system-shaped name badge on it. There is a meaningful difference, and design system colour tokens UK teams are increasingly using to close that gap are finally mature enough to be worth writing about seriously.

    Designer reviewing design system colour tokens UK documentation on a large monitor
    Photo by cottonbro studio on Pexels

    What a real semantic colour token system actually looks like

    The core idea is layered naming. You have primitive tokens at the bottom: raw values like blue-500: #2563EB. Above that sit semantic tokens that describe function rather than appearance: colour-interactive-default, colour-surface-elevated, colour-feedback-error. The primitive never goes directly into a component. The semantic token does. The layer in between is where the magic happens, because when a rebrand requires swapping blue-500 for teal-600, you change one reference and everything that consumes colour-interactive-default updates automatically.

    This three-tier approach, often called primitive, semantic, and component-level tokens, has been championed by Salesforce’s Lightning Design System for years, but UK product teams have been slower to adopt it fully. Part of that is legacy: many British SaaS companies built their design systems before design tokens were a coherent concept, and the technical debt of retrofitting a flat Sass variable file into a structured token architecture is real. The other part is that tooling only recently caught up.

    Why naming conventions matter more than most teams realise

    Here’s where I’d argue most colour system conversations go wrong. Teams spend weeks debating whether blue-500 should be #1D4ED8 or #2563EB, and approximately twenty minutes on naming conventions. Then they ship tokens with names like primaryBlue, brandGreen, and accentColor1, which are essentially useless the moment a new designer joins or the brand team decides teal is the new blue.

    A robust naming convention is schema-first. The structure I’ve seen work best in UK teams follows: [namespace]-[category]-[property]-[variant]-[state]. So ds-colour-text-primary-hover instead of textHoverMain. The namespace scopes the token to your system and prevents collisions if you’re working in a monorepo with multiple products, which plenty of UK B2B companies are. Category and property describe what the token affects. Variant and state handle the stuff that trips everyone up: default versus disabled, rest versus hover versus focus.

    The W3C Design Tokens Community Group published their format specification to standardise how tokens are stored and transferred between tools. It’s not a finished standard yet, but it’s close enough that Figma’s variables implementation and Style Dictionary both align with it reasonably well. If you’re building a token system in 2026 and not at least glancing at that spec, you’re probably building something you’ll have to rebuild in two years.

    Contrast grids: the tooling that makes WCAG compliance tractable

    WCAG 2.1 AA requires a contrast ratio of 4.5:1 for normal text and 3:1 for large text and UI components. WCAG 2.2, which the UK public sector accessibility requirements point to for public sector digital services, doesn’t change those ratios but adds a clearer expectation that you’ve done the work systematically. The problem is that checking every foreground-background combination manually is genuinely tedious. A palette with twelve colours has 66 unique pairs. If you’re also considering dark mode, you’ve effectively doubled your matrix.

    Contrast grids, popularised by Eightshapes’ free tool, solve this by visualising the entire foreground-background matrix at once. You input your palette, and the grid shows every combination colour-coded by whether it passes AA, AAA, or fails entirely. This is enormously useful not just for compliance checking but for making design decisions. When you can see that your neutral-700 passes AA on both your surface-primary and surface-secondary but fails on surface-tertiary, you can encode that constraint directly into your token documentation rather than waiting for it to surface in a QA pass.

    Several UK product teams I’m aware of have started integrating automated contrast checking into their CI pipelines using tools like @accessibility-checker/contrast or custom scripts built on the wcag-contrast npm package. The idea is that a token file change that introduces a failing combination gets flagged in the pull request before it ever reaches a designer’s screen. That’s the right direction. Catching contrast failures at the system level rather than the component level is much cheaper to fix.

    Dark mode is where token systems either prove themselves or collapse

    Dark mode is the stress test every semantic colour token system has to pass eventually. If you’ve built a flat system where components reference primitive values directly, implementing dark mode means touching every component. If you’ve built a properly layered system, dark mode is just a second theme file that remaps your semantic tokens to different primitives.

    In practice, this looks like having two sets of semantic token values: one for light mode, one for dark. colour-surface-primary maps to neutral-100 in light and neutral-900 in dark. A CSS custom property implementation handles the swap via prefers-color-scheme or a data attribute on the root element. Style Dictionary can output both token sets as separate CSS files or as a single file with media query scoping.

    Where teams go wrong is assuming their colour palette works symmetrically in both modes. It almost never does. A contrast grid for your dark mode token mappings is not optional; it’s a separate exercise from your light mode grid, because the contrast ratios change when you flip surfaces. I’d recommend running both grids simultaneously when you’re building out a dual-mode system, and locking the acceptable pairings into your token documentation so that designers can’t accidentally use colour-text-secondary on colour-surface-overlay just because it looks fine in one mode.

    This connects directly to work happening at the component level too. If you’re already thinking carefully about how CSS container queries are reshaping component architecture for UK frontend teams, it’s worth considering how your colour token layer interacts with component-scoped theming. A component that can respond to its container’s size should probably also respond to a locally-scoped theme token rather than relying solely on document-level custom properties.

    Surviving a rebrand with a token system intact

    Rebrands are where semantic token systems pay back every hour of upfront investment. The UK financial services sector goes through brand refreshes constantly, and I’ve seen what happens to design systems that were built around hex values rather than token references. It’s not pretty. Months of find-and-replace work, inevitably inconsistent across products, with rogue legacy values lurking in edge cases until someone files a bug six months later.

    A token system handles this cleanly. Your primitive tier changes. Your semantic tier doesn’t. Your components certainly don’t. If your new brand blue is #1A56DB instead of #2563EB, you update one value, run your contrast grid to confirm nothing broke, and ship. That’s the whole thing.

    Teams building more complex multi-brand or white-label products need to go one level further. Rather than a single primitive-to-semantic mapping, they maintain multiple primitive tiers (one per brand) that all map to the same semantic layer. This is the approach used in sophisticated public sector design systems, and it scales well into the kind of multi-tenant SaaS architecture where a single codebase serves several clients with different brand guidelines.

    The toolchain that makes this tractable in 2026 is roughly: Figma variables for design-side token management, Style Dictionary for transformation and output to CSS, JSON, Swift, Kotlin or whatever your platforms need, and a contrast grid check baked into your release process. None of these tools are particularly new. The difference is that they now work well together, and the naming conventions are stable enough that a token defined in Figma actually means the same thing when it emerges from Style Dictionary on the other side.

    If you’re also thinking about how design system decisions affect the designer-developer handoff, the current state of Figma’s Dev Mode is relevant here; token visibility in dev mode has improved substantially, and a well-structured token system makes the handoff cleaner regardless of which side of the gap you’re on.

    The teams doing this well right now are not necessarily the largest UK product organisations. Some of the most rigorous colour token work I’ve come across is happening at mid-size British fintechs and healthtech companies where the contrast requirements are non-negotiable and the rebrand cycle is fast. Necessity, as always, is doing most of the architectural work.