Web Design & UX/UI

Skip the Figma Handoff When You Build Alone

The default advice for a new client interface is to establish a design system before building screens. I would start with a working screen instead, because a solo freelancer cannot tell which patterns deserve reuse until real content and interactions expose the differences. A component catalog can be valuable later; treating it as the first deliverable makes an untested abstraction the project’s earliest commitment.

A shared component kit is the wrong starting contract

A client asking for “consistent UX” may expect a Figma library, a Storybook catalog, and components that cover future screens. That request sounds efficient, but it asks you to define the future before the client has approved the present. Consider a planning example with four screens: a request form, a results list, a detail page, and a confirmation. Four is the assumed scope of this example, not a measured industry norm. Those screens might all contain buttons while needing different loading states, labels, and error behavior.

I would not promise a complete component library at kickoff, because every undocumented variation becomes either an exception to explain or a change to the library you have already sold. Instead, I would agree on the behaviors the client can inspect: what happens when a field is empty, when a request fails, when a result is unavailable, and when someone uses a keyboard. Those are testable acceptance criteria; “all screens use the system” is not, unless the system already exists and has an owner.

Solo Freelancers Pay the Hidden Upkeep of Design Systems makes the maintenance bill visible, but cost alone is not my objection to starting with a system. The sharper objection is sequencing: a reusable component built before two real uses exist may encode a distinction the product does not need, while omitting one that its first form immediately reveals. That is why I would build the request flow before naming a universal FormField API.

Put a small, explicit boundary in the contract. Shared type styles, color values, and spacing values can live in CSS custom properties immediately, because changing one of those values should predictably affect multiple screens. A component becomes a candidate for extraction only after it appears in three independently reviewed uses; three is a threshold to tune with the client, not a law of frontend architecture. “Independently reviewed” matters because three copies made from one unapproved mockup provide no evidence that the pattern works.

Figma remains useful for discussing layout and content, but it should not be the source of truth for behavior that only a browser can demonstrate. If the contract requires a catalog, price its updates as a separate deliverable with named acceptance criteria rather than assuming they are free by-products of implementation. That keeps the first release accountable to the people using the screen, not to the number of components listed in a sidebar.

Figma parity is a poor proxy for form quality

The most persuasive argument for designing the whole system first is visual consistency. The problem is that a screenshot cannot show whether an error receives focus, whether a label names the right input, or whether a submitted form has actually completed. A polished form can therefore match Figma while leaving a keyboard user unable to understand what went wrong. This is why I would review a browser-rendered flow alongside the design rather than signing off on visual parity alone.

2024-2026 UX advice that wastes solo freelancer time is a useful challenge to busywork, but I would not treat every design artifact as wasted effort. A short annotated state diagram earns its place when a request can be pending, rejected, or complete, because those states otherwise tend to become contradictory notes in tickets. A page of speculative component variants does not earn the same place when nobody has exercised the basic form.

Start the form with HTML labels, the required attribute, and type="email" where they fit the task, because built-in semantics give assistive technology and browsers a meaningful baseline. Add application-specific errors when the native message is insufficient, and always validate again on the server because browser checks can be bypassed. If a custom select is proposed mainly to match a mockup, compare it with a native <select> under keyboard and mobile input before accepting the extra implementation work.

WCAG 2.2 provides a check that is more concrete than “accessible-looking”: its Level AA contrast criterion specifies 4.5:1 for normal text in the applicable cases. That ratio is a published standard, not a claim that contrast alone makes a form accessible. Use axe-core to catch some detectable violations, then manually check focus order, instructions, and error recovery, because automated rules cannot decide whether the client’s wording tells someone how to fix a rejected request.

Visual review still matters. Compare the implemented screen with Figma at the viewport sizes agreed in the brief, and record mismatches that change comprehension or task completion. Do not spend a review meeting tuning a decorative shadow while the submit button can be pressed twice, because duplicate requests affect the user’s outcome and a slight shadow mismatch usually does not. That ordering gives a budget-constrained client a defensible reason for what gets fixed first.

A copied screen can be cheaper than an early abstraction

There are two honest options for repeated UI: local screen patterns and a shared component API. Local patterns win while requirements are changing, because an edit to one screen cannot silently alter another; their cost is some duplicated markup and the need to compare copies during review. A shared API wins once several screens have the same behavior and a stable owner, because one tested fix can reach them all; its cost is deciding which differences become props, variants, documentation, and regression tests.

Suppose the request form and a later account form both have an email field. Extracting a generic field after seeing the second label is premature if one form needs immediate validation and the other validates on submission, because a single error prop does not settle when an error appears or where focus goes. Keep the markup local until those decisions have been made in the browser. Reuse the shared color and spacing tokens meanwhile, since they do not require both forms to behave alike.

This is not an argument for indiscriminate copying. Set an initial abstraction budget of 90 minutes for a candidate pattern; that is a planning cap to revise, not a measured saving. If making the shared API takes longer than that because each screen needs exceptions, stop and write down the differences. The notes are useful evidence for the next estimate, whereas a component with many conditional props can make the next screen harder to price.

React 19 does not make a component reusable merely because it can be imported, since reuse depends on whether its interaction contract survives another context. Radix UI can reduce the work of implementing certain complex primitives, but adopting it still requires testing your composition and styles in the actual flow. shadcn/ui offers code you can edit in the project, which can be preferable to a sealed dependency when changes are expected; the trade-off is that the project owns the edited code. Those are choices to make after identifying an interaction need, not reasons to populate a library before the first screen works.

If the client already has a maintained system with documented states and someone responsible for releases, the shared API may win from day one because the freelancer can build against an existing contract. Without that owner, local patterns are often the safer default because their costs are visible in the screen being changed. The decision should appear in the estimate as an assumption the client can confirm, rather than hiding inside a line item called “frontend development.”

A browser check earns its place before a component catalog

A small release check gives the client evidence that the primary task still works after edits. Begin with the form’s failure path, because a successful submission alone will not reveal whether someone can recover from invalid input. The following Playwright test is a runnable baseline: save it as form.spec.js after installing @playwright/test and its Chromium browser, then run npx playwright test. It uses an inline form so the behavior is reproducible before you point the test at the client’s page.

import { test, expect } from '@playwright/test';

test('an invalid email blocks the form', async ({ page }) => {
  await page.setContent('<form><label>Email <input type="email" required></label><button>Send</button></form>');
  const email = page.getByRole('textbox', { name: 'Email' });
  await page.getByRole('button', { name: 'Send' }).click();
  await expect(email).toBeFocused();
  expect(await email.evaluate(node => node.checkValidity())).toBe(false);
  await email.fill('a@example.com');
  expect(await email.evaluate(node => node.checkValidity())).toBe(true);
});

Replace the inline markup with a visit to the implemented page before delivery, because testing the example alone proves nothing about the client’s code. Keep assertions tied to roles and visible outcomes rather than CSS class names, since a class can change during a harmless visual edit while the task remains the same. Add a test for the server’s rejected response when that path exists, because native constraint validation cannot detect an address the server refuses.

For a first review, ask the client to observe five completed attempts at the primary task with representative content. Five is a small pilot size to arrange, not a statistical claim about all users; record where each attempt stops and what the person expected next. Pair those observations with a Playwright regression check and an axe-core pass. If the page has enough real traffic, watch Interaction to Next Paint in field data as well: Google’s published “good” threshold is 200 milliseconds at the 75th percentile, so a single fast run on your laptop cannot establish that users meet it.

GitHub Actions can run the browser check on changes once the project has a reliable build, but a solo freelancer should not promise a large test pipeline before the first release because maintaining a flaky pipeline consumes the same limited delivery time as maintaining a catalog. One stable test of the client’s main task is a better starting obligation than many screenshots nobody checks after a content change.

The first deliverable should be a working decision

At the next kickoff, choose the client’s primary task and ask for its success, invalid-input, and server-error states. Build those states in one browser screen before quoting a component catalog. Record which styles are shared and which interactions differ; then price extraction only when reviewed screens show a genuine repeat. That first screen gives both you and the client something concrete to accept, change, or decline.