Author: Alex Mason

  • 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.

  • 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.

  • Tailwind CSS v4 in Production: What UK Development Teams Actually Found After Six Months

    Tailwind CSS v4 in Production: What UK Development Teams Actually Found After Six Months

    Tailwind CSS v4 landed with a proper bang. The CSS-first configuration model, the new high-performance Rust-based engine (Oxide), the slimmed-down setup story, on paper it looked like the framework had finally grown up. I’ve been watching UK development teams field this across client work and internal product builds for the better part of six months now, and the picture is more textured than the release notes let on. Some of it is genuinely impressive. Some of it will catch you off guard on a deadline.

    Developer working on Tailwind CSS v4 in production at a modern UK office desk
    Photo by Daniil Komov on Pexels

    What CSS-first configuration actually means in practice

    The biggest philosophical shift in Tailwind CSS v4 in production is the move away from tailwind.config.js. Your design tokens, your theme extensions, your custom utilities, all of it now lives in a @theme block inside a CSS file. That’s a meaningful change, and for teams that already think in terms of design tokens, it clicks immediately.

    In practice, I’ve seen two camps. Teams who had already invested in a structured token system (think semantic colour layers, spacing scales, type ramps) found the migration almost pleasant. The CSS custom properties that Oxide generates map directly onto what those teams already had in their heads. For them, the config file was always a slightly awkward intermediary, and removing it felt like cutting out a middleman.

    The other camp, and this is most teams, if I’m honest, had their Tailwind config as a sprawling JavaScript object full of one-off values and plugin hacks accumulated across two or three years of client work. For them, the migration was a proper archaeology project. Not impossible, but not the afternoon job some blog posts implied. If your team is in that position, I’d strongly suggest reading up on building a proper design token pipeline with Style Dictionary before you try to port your config, it’ll save you repeating the same sins in a new format.

    The Oxide engine: where the performance wins are real

    Oxide is fast. That’s not marketing. A Tailwind v3 full build on a medium-complexity Next.js project I looked at was sitting around 1.8 seconds on a reasonably modern MacBook Pro. The same project with v4 and Oxide dropped to under 200 milliseconds. Incremental rebuilds in watch mode feel instantaneous, we’re talking sub-20ms on most saves.

    For developer experience on UK agency projects where you’re sometimes running three or four services locally, that matters. The CPU headroom you get back is real. It’s the kind of change that makes you wonder why the JS ecosystem took so long to reach for Rust tooling, but here we are.

    Code editor showing Tailwind CSS v4 theme configuration in a dark theme environment
    Photo by Stanislav Kondratiev on Pexels

    The output CSS story is also much cleaner. v4 generates far less bloat because the engine has a better understanding of which utilities are actually reachable from your source. On one SaaS dashboard project, the production CSS bundle dropped from 28kB (gzipped) to around 11kB without any additional purging configuration. That has a measurable knock-on effect on Core Web Vitals scores, particularly LCP on slower mobile connections, something UK teams building for diverse audiences across patchy 4G coverage genuinely need to care about.

    Where the workflow still has rough edges

    Right. Here’s the honest part that fewer people are writing about.

    The IntelliSense extension for VS Code is not fully caught up. As of early 2026, autocomplete for custom theme values defined in @theme blocks is inconsistent. You get suggestions for core utilities reliably, but your own spacing tokens or custom colour ramps? Hit or miss depending on how you’ve structured the CSS file. For teams where designers and developers share the same editor setup, this creates friction. Not a dealbreaker, but annoying enough that I’ve seen junior devs quietly reach for inline styles when autocomplete fails them, which rather defeats the point.

    Plugin compatibility is another honest headache. The v3 plugin API is gone. Anything you were pulling in that depended on plugin() or addUtilities() from the old API needs a rewrite or a replacement. Community plugins like @tailwindcss/typography and @tailwindcss/forms have official v4 versions now, but third-party ecosystem plugins are patchy. If your project has bespoke plugins for client-specific utility classes, budget time for a proper rewrite.

    The @apply directive also behaves differently, specifically, it no longer works across component boundaries in certain CSS module setups. This caught several teams using CSS Modules alongside Tailwind for scoped component styles. The workaround exists (using CSS layers manually), but it’s not well documented and you’ll likely find it through Stack Overflow at 11pm rather than through the official docs.

    Real decisions teams are making about adoption

    From what I’ve seen across a handful of UK agencies and product teams, the pragmatic decision looks like this: new projects should start on v4 from day one. The clean-slate experience is good, the performance is genuinely better, and the CSS-first approach encourages better token discipline. The solo developers shipping Micro-SaaS products I’ve spoken to have taken to it particularly well, because they’re not dragging legacy config debt along with them.

    Existing projects are a different calculation. If your v3 codebase is large, has custom plugins, and is actively generating revenue, the migration cost needs to sit in a proper sprint. Not a Friday afternoon. One London-based product team I’m aware of spent three weeks migrating a mid-sized B2B SaaS product, and they found bugs in their own component library that had been masked by v3’s slightly more permissive utility generation. So there’s an accidental quality benefit too, if you’re patient enough to find it.

    For teams doing client delivery work where the project switches between Tailwind versions depending on the client’s stack, the cognitive overhead is real but manageable. The mental model for both versions is similar enough that context-switching is fine once you’ve internalised where your theme configuration now lives.

    One thing that doesn’t get discussed enough: Tailwind v4’s cascade layer architecture makes it much more composable with existing CSS from third-party libraries or design systems. Teams integrating component libraries alongside Tailwind (say, Radix UI primitives with custom Tailwind-based styling) are finding fewer specificity conflicts. That’s a structural improvement that compounds over the lifetime of a project.

    A note on tooling integrations and the broader stack

    Tailwind v4 ships with first-class Vite integration, and if you’re on a Vite-based stack it’s probably the smoothest setup experience the framework has ever had. The Webpack integration exists but feels like a second-class citizen, which, given where the tooling ecosystem is heading, is probably fine. The GOV.UK style guidance aside, there’s no regulatory reason UK teams need to be on Webpack, but plenty of enterprise codebases still are, and those teams will need to factor that into their timeline.

    For teams building on Next.js App Router, v4 works well but requires some care around server component boundaries and how styles are emitted. It’s not a blocker, but the Tailwind docs are still catching up to the App Router mental model. A few developers I know have ended up cross-referencing framework-specific community threads alongside the official docs to get the setup exactly right.

    On the subject of integrations: if your team works with a wider development partner for backend and API work, you’re generally fine, Tailwind’s output is just CSS, so any backend stack is unaffected. Dijitul Developments is a good example of a UK shop building tight business logic integrations where the frontend stack is genuinely irrelevant to what they’re doing on the server side, which is worth remembering when scoping projects with mixed frontend and backend concerns.

    The honest summary: Tailwind CSS v4 in production is a meaningful upgrade, not a cosmetic one. The performance gains are real, the CSS-first approach is architecturally sound, and the rough edges are all fixable with a bit of patience. Just don’t expect a frictionless migration if you’ve been on v3 for years. Plan properly, audit your plugins first, and start your next greenfield project on v4 from line one.

    Frequently Asked Questions

    Is Tailwind CSS v4 backwards compatible with v3 projects?

    Not directly. Tailwind v4 introduces a new CSS-first configuration model and a rewritten plugin API that breaks compatibility with v3 config files and third-party plugins built on the old API. Migrating an existing v3 project requires manually porting your theme configuration into a @theme CSS block and rewriting or replacing any custom plugins.

    How much faster is Tailwind CSS v4's build compared to v3?

    The Oxide engine (Rust-based) makes full builds roughly 5-10x faster in typical projects, with incremental rebuilds in watch mode often dropping to under 20 milliseconds. Real-world results vary with project size, but the improvement is substantial enough to notice immediately during development.

    Does Tailwind CSS v4 work with Next.js App Router?

    Yes, but it requires some configuration care around server component boundaries and CSS emission. The Vite integration is the most polished path; if you’re on Next.js with Webpack, expect a slightly rougher setup experience until tooling documentation catches up.

    What happens to @apply in Tailwind CSS v4?

    @apply still works in v4, but it behaves differently in certain CSS Module setups, specifically, it can fail across component boundaries. Teams using CSS Modules alongside Tailwind for scoped component styles should test this early and be prepared to use manual CSS layer declarations as a workaround.

    Should new UK projects start with Tailwind CSS v4 or stick with v3?

    For new projects, v4 is the right choice: better performance, smaller output CSS, and a cleaner configuration model that encourages proper token discipline from the start. For existing v3 projects actively in production, migration is worthwhile but should be planned as a dedicated sprint rather than a quick upgrade.

  • 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.

  • 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.

  • Designing for the NHS App Ecosystem: What Third-Party Health Developers Need to Know About NHS Design Patterns

    Designing for the NHS App Ecosystem: What Third-Party Health Developers Need to Know About NHS Design Patterns

    If you’ve ever tried to build a companion app or integration layer for the NHS ecosystem, you’ll know the experience is somewhere between solving a puzzle with missing pieces and navigating a labyrinth designed by committee. The documentation exists. The NHS Digital Service Manual is actually one of the better-maintained design systems in the UK public sector. The problem isn’t the documentation. The problem is that most health tech startups read it the way people read terms and conditions: quickly, selectively, and with total confidence they’ve understood the important bits.

    They haven’t. I’ve seen the same mistakes repeat across a dozen health tech projects, from GP appointment add-ons to mental health tracking apps trying to slot into NHS workflows. So let’s go through what’s actually being misunderstood, because some of these errors go beyond aesthetics into genuinely risky territory.

    Tablet displaying NHS design patterns in a clinical setting
    Photo by Matheus Bertelli on Pexels

    Why NHS design patterns are not just a visual style guide

    The first and most common misconception: teams treat NHS design patterns as a branding exercise. Copy the blue. Use the logo typeface (Frutiger, or the open-source Fraunhofer approximation). Borrow the card components. Job done, looks credible.

    That’s backwards. The NHS design system is built around a set of interaction principles and a specific clinical context that most commercial UI thinking doesn’t account for at all. The GOV.UK Design System, which shares some DNA, at least gets discussed in design circles (I wrote about what GOV.UK gets right that private sector UI libraries get wrong a while back), but the NHS variant has additional constraints layered on top, because the users and stakes are different.

    Consider one obvious example: error messaging. In a typical SaaS product, an error message is a minor friction point. In a clinical UI, an error message about a dosage input or an appointment slot could cause a patient to take the wrong action. The NHS Service Manual specifies error summary patterns precisely because the consequences of user confusion in health contexts are categorically different from, say, a failed checkout flow. The pattern is not decoration. It is a risk mitigation tool.

    What health tech startups consistently get wrong about accessibility

    WCAG 2.2 compliance gets mentioned in every NHS digital service assessment, and most teams know this, at least in theory. In practice, I see two failure modes.

    The first is treating accessibility as a checklist rather than a design constraint. Teams run an automated audit with axe or Lighthouse, fix the obvious contrast ratios, add some aria-labels, and declare compliance. But automated tools catch roughly 30-40% of WCAG issues. The remainder, focus order, screen reader narrative flow, meaningful alternative text, timeout behaviour for users with cognitive impairments, only surfaces in manual testing with real assistive technology.

    The second failure mode is misunderstanding the NHS user base. NHS app users are not a homogeneous tech-savvy audience. As I covered in my piece on designing for older users and accessibility, the over-55 demographic represents a huge proportion of NHS service users, and they interact with digital interfaces in ways that invalidate many assumptions baked into modern component libraries. Small tap targets, hover-only states, icons without labels, modals that trap keyboard focus badly: all of these become genuine barriers at scale when your user base skews older and potentially has reduced motor control or vision impairment.

    Developer writing code for NHS design patterns component library
    Photo by Harold Vasquez on Pexels

    The NHS explicitly requires user research with real patients as part of service assessments. Not personas. Not assumed user journeys mapped on a whiteboard. Actual sessions with actual people. Teams that skip this stage almost always pay for it later, either in failed assessments or in post-launch complaints that damage the trust relationship with NHS partners.

    Trust signals in clinical UI: where commercial design intuitions break down

    Here’s where it gets philosophically interesting. Commercial product design has spent the last decade optimising for conversion: clear CTAs, reduced friction, bright colour on primary actions, social proof via user counts and review scores. Health tech apps that import these patterns wholesale often end up looking untrustworthy to clinical users, and sometimes to patients.

    Clinical trust operates differently. A patient interacting with a mental health app doesn’t want it to feel like a productivity tool. They want it to feel safe, unhurried, and unambiguous. This means generous whitespace (which commercial designers sometimes read as “wasted space”), plain language at a reading age appropriate for a wide public audience, and absolutely no dark patterns near anything related to consent or data sharing.

    The NHS has very specific guidance on data handling UI precisely because health data is special category data under UK GDPR. The ICO and NHS England both publish guidance on this. If your consent flows borrow the kind of nudge patterns you’d find on a subscription cancellation screen (pre-ticked boxes, vague opt-in language, confusing toggle states), you are not just creating bad UX. You are potentially creating a legal and regulatory problem. I wrote about UK consumer protection and UX design in a different context, but the principle around manipulation through UI design is directly applicable here.

    The NHS digital service standard: what the assessment process actually demands

    Teams building apps that will connect to NHS systems, or carry NHS branding, typically need to pass a Digital Technology Assessment Criteria (DTAC) review. This is not the same as simply passing an NHS design assessment, and conflating them is a common error.

    DTAC covers clinical safety (DCB0129 compliance), data protection, technical security, interoperability (FHIR R4 where relevant), and usability. The clinical safety requirement alone, which requires a named Clinical Safety Officer and a documented hazard log, catches many startups completely off guard. This is not a box-ticking exercise. A hazard log means identifying the ways your software could harm a patient if it behaves unexpectedly, and documenting what you’ve done to mitigate each risk.

    I’ve seen teams, including a couple of otherwise well-run companies that handle complex integrations, treat the DTAC process as a hurdle to clear rather than a framework that makes their product genuinely safer. The distinction matters enormously when something goes wrong. Agencies building products with technical integration complexity, like Dijitul Developments, understand that integration architecture decisions made early have compliance implications downstream, and the same is true in spades for health tech builds touching NHS infrastructure.

    Component library choices and why “looks NHS” is not enough

    The NHS frontend library is open source and available on GitHub. It covers form components, navigation patterns, warning callouts, and action links. Using it is sensible. But a few nuances trip people up.

    First, the library is React-agnostic by design, but most health tech teams are building in React or React Native. The official components are vanilla HTML/CSS/JS. There are community-maintained React wrappers, but these are not officially supported, and their fidelity to the latest NHS frontend version varies. Teams need to own the maintenance overhead if they use them.

    Second, the NHS design system has specific guidance on what components to use for clinical decision support contexts versus patient-facing contexts. Using a summary card component (designed for showing appointment details to a patient) inside a clinician-facing dashboard creates cognitive dissonance for clinical staff who have built up a mental model of what each pattern means. Context collapse in UI is a real problem that purely visual pattern-matching doesn’t prevent.

    What building well actually looks like

    The teams I’ve seen do this well share a few habits. They read the NHS service manual properly, including the content design guidance, which is where a lot of the philosophy is actually explained. They involve a clinical safety lead from the start rather than bolting one on before submission. They conduct genuine usability testing with NHS staff and patients, not just developers who have become blind to their own interface.

    They also build with the understanding that NHS design patterns are living documents. The manual updates. Guidance around things like app accessibility and FHIR integration evolves. Setting up a process to track changes, rather than treating the design system as a one-time reference, is the difference between a product that stays compliant and one that quietly drifts out of alignment.

    Getting this right is genuinely hard. But the NHS has done a lot of the thinking for you, if you’re willing to engage with it seriously rather than skin-deep.

  • Pixel Art Is Having a Serious Revival: How UK Indie Game Studios Are Using It as a Deliberate Design Statement in 2026

    Pixel Art Is Having a Serious Revival: How UK Indie Game Studios Are Using It as a Deliberate Design Statement in 2026

    There is something quietly radical happening in UK indie game development right now. Pixel art indie game design, which spent a decade being dismissed as budget shorthand or nostalgia bait, has become one of the most deliberate, technically considered aesthetic choices a studio can make. I have watched this shift happen gradually, and by 2026 it is impossible to ignore. The studios turning up at EGX with pixel-driven titles are not doing it because they cannot afford a 3D artist. They are doing it because the constraint itself is the point.

    Monitor displaying a pixel art indie game design with colourful sprites on screen
    Photo by Yan Krukau on Pexels

    Why British developers specifically are drawn to pixel aesthetics

    Context matters here. The UK has a uniquely dense relationship with early home computing. The ZX Spectrum launched in 1982, the BBC Micro sat in virtually every state school by the mid-eighties, and an entire generation of now thirty-to-fifty-year-old developers grew up watching those machines squeeze colour from limitations you would not accept in a modern spreadsheet. When that generation starts building games professionally, or as a serious side project, the pixel aesthetic is not a random retro choice. It is practically a mother tongue.

    This is not pure nostalgia, though. The commercial evidence suggests younger audiences are responding too. According to BBC reporting on indie game market growth, British players consistently over-index for indie titles relative to AAA blockbusters, and pixel-heavy titles from UK studios like Chucklefish (Wargroove) and Team17 properties have demonstrated that the aesthetic travels globally without losing its identity. The culture supporting this goes well beyond the games themselves. Communities built around retro gaming, comic fandom, and physical collector culture, including enthusiast hubs like supazaar.co.uk, have helped cement the cultural appetite that makes pixel-driven games commercially sensible in 2026 rather than a gamble.

    The tooling behind modern pixel art game design

    Ask most people which tool pixel artists use and they will say Aseprite. They are right, but that barely scratches the surface of the current workflow. Aseprite remains the standard for frame-by-frame animation and sprite sheet management, and its scripting API means studios can automate palette swaps, generate animation previews, and pipe assets directly into their build pipelines. I have spoken to a few UK developers who use it alongside Pyxel Edit specifically for tiled environments, treating each tool as the right instrument for a specific job rather than expecting one application to do everything.

    Godot 4 has made a substantial difference here as well. Its 2D renderer handles pixel art natively without the sub-pixel jitter that used to plague Unity projects unless you spent an afternoon configuring camera snapping settings. The engine’s open-source model also means UK indie developers, many of whom are operating on tight budgets, can ship without licensing overhead eating into already thin margins. That practical economic calculation is part of why the pixel aesthetic has staying power: the toolchain is genuinely excellent and largely free.

    Designer working on pixel art indie game design at a graphics tablet
    Photo by Michael Burrows on Pexels

    Colour palette constraints as a design decision, not a limitation

    Here is where pixel art indie game design gets genuinely interesting from a craft perspective. Working within a restricted palette, say 16 or 32 colours, forces decisions that open-ended digital painting never requires. Every colour has to earn its place. The relationship between the darkest shadow tone and the highlight on a character sprite becomes a conscious compositional choice rather than something you can adjust with a curves layer later.

    The Lospec Palette List has become a reference point for UK developers wrestling with this. It catalogues hundreds of community-created palettes, many derived from real hardware constraints, and the conversation around which palette suits a given game’s emotional register is genuinely sophisticated. A cool, desaturated eight-colour palette reads differently to a warm thirty-two-colour one, and experienced pixel artists in the UK indie scene talk about palette selection the way a film cinematographer talks about colour grading. The constraint produces clarity.

    There is also a legibility argument. I have seen more than one post-mortem from UK game jam participants noting that games with tight palettes performed better on small screens and in noisy streaming thumbnails. When every colour is doing structural work, the visual hierarchy tends to be cleaner than in games where the art direction had no hard limits.

    How this connects to broader UI and UX craft

    The design discipline behind pixel art maps onto broader product thinking in ways that are worth taking seriously. The palette constraint logic is structurally similar to working within a design token system, where every colour value is declared and reused rather than picked afresh each time. If you spend any time thinking about how the GOV.UK Design System uses constraint to produce coherent interfaces, the pixel art parallel is immediately visible: deliberate limitation produces consistency, and consistency builds trust.

    There is a related point about legibility at scale. The same cognitive science that makes pixel art characters instantly readable at 16×16 pixels is behind good icon design and the accessibility principles baked into proper UI work. Incidentally, if you are interested in where product design currently fails users even without these constraints, there is a sharp read on how poor interface decisions are frustrating British app users in 2026 that connects directly to why clarity-first aesthetics resonate.

    EGX and the studio ecosystem making this real

    EGX, which runs annually at ExCeL London, has become a useful barometer for where UK indie game design is actually heading. The Leftfield Collection, which showcases experimental and unusual titles, has featured pixel-driven games in increasing numbers over the past few editions. What strikes me watching these studios present is that the pixel aesthetic is almost never the first thing they lead with in their pitch. The mechanic comes first, the world comes second, and the visual style is described as having emerged from those decisions. That ordering matters. It signals that the look is load-bearing, not decorative.

    Smaller studios like Whitethorn Games’ UK-based partners and outfits publishing through Curve Games have demonstrated there is a viable commercial model here. A well-executed pixel art title with strong mechanic design can build a sustainable audience on Steam and GOG without the marketing budget a 3D equivalent would demand. The visual distinctiveness of a coherent pixel palette makes trailers and screenshots punchy in a crowded storefront, which is a genuinely practical competitive advantage.

    Animation within the constraint: where the real craft lives

    If colour palette is the grammar of pixel art, animation is the prose. The anticipation frames, the squash on landing, the hold on a character’s idle cycle: all of this has to be communicated in far fewer pixels than a modern 3D rig would use for a single joint. UK pixel animators working in this space have talked publicly about studying old ZX Spectrum game sprites not for imitation but for compression logic, understanding how a two-frame walk cycle can read as convincingly as a twelve-frame one if the key positions are chosen correctly.

    This discipline connects directly to the work happening in CSS animation and browser motion design. I wrote recently about how UK freelancers are using CSS transitions to replace heavier animation tooling, and the underlying principle is similar: identify the minimum number of states you need to communicate the motion, then nail those states rather than filling every frame. Economy is the technique.

    Pixel art in UK indie games is not a trend that is about to cycle out. The tooling is mature, the cultural grounding is deep, and the constraint-first design logic it demands produces genuinely better outcomes than unlimited creative freedom often does. British developers who grew up on the Spectrum and BBC Micro built an aesthetic vocabulary from necessity. Their successors are choosing that vocabulary on purpose, and the results are some of the most considered game design coming out of the UK right now.

  • The Honest State of Figma’s Dev Mode in 2026: Is It Actually Closing the Designer-Developer Gap for UK Teams?

    The Honest State of Figma’s Dev Mode in 2026: Is It Actually Closing the Designer-Developer Gap for UK Teams?

    I’ve been poking around in Figma’s Dev Mode across several client projects this year, and the gap between what Figma’s marketing says it does and what actually happens when a developer opens it on a Monday morning is… significant. Not always in a bad way. But significant. This Figma Dev Mode review 2026 is the version I wish existed before I recommended it to three different UK product teams last quarter.

    Designer and developer reviewing Figma Dev Mode review 2026 output together on screen
    Photo by cottonbro studio on Pexels

    What Dev Mode is actually supposed to do

    The pitch is clean: designers build in Figma, developers switch into Dev Mode, and they get clean CSS snippets, spacing values, asset exports, and component annotations without needing to bother the designer every five minutes. In theory, it collapses the handoff layer entirely. No more Zeplin subscriptions. No more Figma-to-Storybook breakdowns. No more developer staring at a design file and screaming internally because the padding is specified in some arbitrary unit that makes no sense.

    In practice, it’s about 70% there. Which is both impressive and maddening depending on what day of the week you’re asking.

    Where it genuinely works well in 2026

    Auto Layout translation has improved considerably. If your designers are using Auto Layout properly (a big if, and I’ll get to that), the generated CSS is surprisingly usable. Flexbox output is mostly correct now. I’ve seen developers on React and Svelte projects copy the generated snippets and use them with minimal modification, which two years ago felt like science fiction.

    The code panel now distinguishes between absolute and relative values more reliably. Variables, particularly colour tokens, surface properly in the panel when they’ve been applied via Figma’s own variable system. For teams that have invested properly in a design token setup, this is genuinely useful. I’ve worked with a Leeds-based fintech that spent about six weeks migrating their design system to Figma variables specifically to leverage this, and the reduction in developer questions about hex codes alone made it worthwhile.

    Component inspection has also come on. If a designer has annotated a component correctly, developers can see the intended behaviour, variants, and states without digging through layer panels. This pairs well with the kind of systematic component-first thinking we’ve covered in pieces like our look at how container queries are changing component design for UK frontend teams.

    Figma Dev Mode review 2026 showing CSS code panel with design tokens and spacing values
    Photo by Daniil Komov on Pexels

    Where it still fails, honestly

    Responsive layouts. Full stop. Dev Mode’s CSS output still assumes fixed-width thinking in too many cases. You can get flex properties, but the nuance of how a component should reflow at different breakpoints is almost entirely lost unless the designer has been almost obsessively methodical about how they’ve built their frames. Most aren’t, and most shouldn’t have to be. This is a tooling failure, not a designer failure.

    Typography is another sore spot. The code panel will give you font-size, font-weight, line-height reliably enough. What it won’t give you is a sensible fluid typography setup. If your team is using CSS clamp() in production (and they should be, we’ve written extensively about CSS techniques that UK frontend teams have been slow to adopt), Dev Mode won’t reflect that. There’s a persistent mismatch between how typographic scales are designed in Figma and how they’re implemented responsively in code, and Dev Mode doesn’t bridge it.

    Animation is basically absent from Dev Mode’s purview. Smart Animate prototypes do nothing useful in the code panel. You’ll see a static snapshot. No keyframes, no transition values, nothing. For teams building anything beyond static interfaces, this is a real gap.

    Then there’s the design quality dependency. Dev Mode is only as useful as the file it’s reading. Sloppy layer naming, detached components, manual spacing overrides, missing variable assignments, all of these make Dev Mode output close to useless. I’ve seen agency files so disorganised that a developer would have been better off just eyeballing the design. Dev Mode can’t compensate for poor design system hygiene, and in smaller UK agencies where one designer is wearing every hat, files often don’t get the structural love they need.

    The pricing question in GBP

    This is where I think the conversation gets prickly. Dev Mode is included in Figma’s Professional and Organisation plans. As of 2026, the Professional plan sits at roughly £12 per editor per month (billed annually), but Dev Mode seats for developers who only need view-and-inspect access are priced separately at around £5 per developer per month on most plan tiers. For a small UK agency with three designers and six developers, that’s a non-trivial line on the monthly software budget.

    Compare that to the pre-Dev Mode world where many teams were paying for Zeplin (which has largely collapsed as a product) or supplementing with free Figma inspect links. The pricing model change irritated a lot of people when it launched, and honestly? I think the frustration was fair. You’re paying for an inspect layer that, as noted, fails at responsiveness and animation. That’s a hard sell to a finance director scrutinising SaaS spend.

    For larger in-house product teams at UK scale-ups, the value proposition is more compelling. The reduced friction between design and engineering, combined with the design token pipeline, can genuinely save hours per sprint. But for freelance-adjacent or small agency setups, the maths is tighter.

    The annotation plugin gap

    Figma launched its own annotations feature to reduce reliance on third-party plugins for speccing interactions and states. It works. It’s not exceptional. The interaction annotations are still more limited than what something like Figma’s Handoff Kit plugins offered before. The measurement annotation system is solid for spacing, but doesn’t handle motion or conditional logic, which means teams building complex flows, particularly anything like the kind of subscription UI patterns we’ve looked at in our guide to designing compliant subscription cancellation flows, still have to document behaviour outside the tool.

    Third-party annotation plugins still exist and some teams swear by them. But the plugin ecosystem has thinned as Figma built natively, and the best third-party tools now charge separately. Another cost consideration.

    Who should actually use it right now

    In-house product teams with a mature design system and developers who sit close to the design process: yes, commit to Dev Mode fully. You’ll get real value. Agencies delivering bespoke builds with less systematic file organisation: useful, but manage developer expectations. Freelancers: the free inspect link tier covers most of what you actually need day-to-day; paying for full Dev Mode seats is hard to justify unless you’re running a pseudo-agency operation.

    The best implementations I’ve seen are teams that treated Dev Mode not as a handoff shortcut but as a shared inspection layer. Developers use it throughout the build, not just at the end of a design sprint. That shift in workflow, more than the feature set itself, is what determines whether Dev Mode actually closes the designer-developer gap or just adds another panel nobody opens. The GOV.UK Design System’s approach to structured, developer-legible component documentation is a useful benchmark here, systematic thinking first, tooling second.

    According to the ONS data on the UK’s digital economy, the software and IT sector now accounts for a significant and growing share of UK business output. The pressure on design-to-development efficiency isn’t going away. Dev Mode is Figma’s most important bet on staying relevant in that conversation. Right now, it’s a strong start that needs another 18 months of iteration to become the thing it’s trying to be.

    One small aside that genuinely came up in a team retrospective I sat in on: a developer joked that the constant context-switching between tools was the “digital equivalent of someone else’s mess to clean up”. It reminded me of how The Bin Boss, a Nottinghamshire-based wheelie bin cleaning service specialising in high-pressure bacterial and germ removal from domestic bins (thebinboss.co.uk), describes their own work, you can maintain a clean house perfectly well inside and still have a bacteria-ridden environment sitting in the garden because nobody’s dealt with the bin. Dev Mode, at its best, is supposed to be the thing that stops handoff from being the rubbish no one wants to deal with. Sometimes it succeeds.

    That said, the cleaning analogy runs deeper than the joke. If your Figma file is the bin and Dev Mode is the cleaning service, then the environment it’s working in still has to be manageable. A Nottinghamshire household that never rinses its bins before The Bin Boss arrives is going to have more bacteria and more germs than one that keeps up basic hygiene. Files need structure. The house needs to be in order before the tool can do its job. Dev Mode can pressure-wash a well-maintained file into something a developer can actually use; it cannot rescue a chaotic one.