Form Controls After Import: Inputs, Selects, and Buttons
Which HTML form controls become editable boxes in Figma and which stay browser-drawn: inputs, selects, buttons, checkboxes, and the CSS behind each.
When you bring an HTML form into Figma, text inputs, textareas, and buttons are the easy part: they are ordinary styled boxes in CSS. Selects, date pickers, range sliders, file inputs, color pickers, progress bars, and meters are different, because the browser draws parts of them itself and CSS cannot reach those parts. Expect the first group to be editable boxes you can restyle, and plan to redraw the second group by hand.
This page sorts form controls by how much CSS controls them, then gives a checklist for the Figma side. The CSS facts come from MDN, as of 2026. It doesn't promise an exact result for every tool and control, so check the form you import against the live page.
Which controls CSS can style: easy, harder, and not at all
MDN groups form controls into three tiers, and that grouping is a good predictor of what you will find in a design file after an import.
| Control | CSS styling, per MDN | What to expect in Figma |
|---|---|---|
form, fieldset, legend, label, output | Easy | Plain frames and text |
Single-line text input (except type="search"), textarea | Easy | A box with border, radius, fill, and placeholder or value text |
button | Easy | A box with a text label |
Checkbox, radio, type="search" | Harder | Check the checked state and the indicator |
select, option, optgroup, datalist | Not by CSS alone | Closed box only, the open list is browser UI |
color, date controls, range, file, progress, meter | Not by CSS alone | Redraw the internals yourself |
The MDN guide to styling web forms is explicit about the last row. The calendar of a date picker and the dropdown button of a select are internal components that CSS cannot reach. The file input is a partial exception: its button can be styled with ::file-selector-button, but the filename text beside it cannot.
Text inputs, textareas, and buttons
A text input is a rectangle. Its width, padding, border, border-radius, background, and box-shadow are all regular CSS, so they have regular equivalents on a Figma frame. For the border side of this, see borders, radius, and outlines.
Buttons follow the same logic, with one wrinkle. MDN recommends <button> over <input type="submit"> for styling. In Chrome, an input type="submit" does not inherit its font from the parent and uses font-family: system-ui, so its label can differ from the rest of the form. A <button> also accepts pseudo-elements, so a page can add an arrow with button::after { content: " >>>"; }. Generated content like that is not an element in the page, so look for it by eye: if the live button shows an arrow or an icon and your Figma button does not, that is where it went.
Hover and focus states, such as button:hover and button:focus, are a page state rather than a layout. A single import shows the page in one state, so draw the others yourself.
Why fonts differ between controls and the page
Some widgets do not inherit font-family and font-size from their parent. Browsers often show the system default instead. MDN suggests this reset when you want the controls to match the page:
button,
input,
select,
textarea {
font-family: inherit;
font-size: 100%;
}
If the page you import has no such reset, the controls were using a different font from the surrounding text, and that is what you should see in the file. If it does have the reset, the controls should match the body copy. Either way, click a placeholder or a button label and read its font in the right panel before you assume it matches. The CSS text styles in Figma article covers line height, letter spacing, and per-run formatting for the text layers themselves.
Size is the other surprise, and it comes from the box model. Each widget has its own default border, padding, and margin, so two fields with the same declared width can render at different sizes. MDN equalizes them with box-sizing: border-box and consistent values. When two fields in your import look slightly different in width, check the page's box-sizing rule before blaming the import.
Native widgets and appearance
The appearance property controls whether a widget gets its native, OS-themed look. Per MDN, appearance: none gives the widget a primitive look that CSS can style while its native behavior stays. auto renders interactive widgets with their native appearance. textfield makes certain input types look like a text field, which is how a page hides the spinner on a number input.
Two consequences matter for a design file:
- Behavior survives, looks do not. Arrow keys still increment a number input after its spinner is hidden. The widget still works. It just doesn't look native anymore.
- Checkboxes and radios can disappear. With
appearance: none, a checkbox or radio button may become invisible while staying interactive. Clicking itslabelstill toggles it. Pages that do this draw their own indicator from other elements. In Figma, verify that the checked and unchecked indicators exist as separate layers or states.
Select: closed state versus the open list
A select takes two forms. With the default size="1" and no multiple, it is a drop-down, and its implicit ARIA role is combobox. With multiple or a size above 1, it is a scrolling list box with role listbox. A list box shows its rows inline, so it is much easier to represent in a design file than a drop-down.
For a drop-down, MDN says that without modern customization you are limited to the box model, the displayed font, and removing the default look with appearance. So the closed select is a box you can match: border, padding, font, and the arrow. The open list is the browser's own UI, and it is not part of the page's layout. If your design needs to show the open state, build it as a separate frame.
Newer browsers support customizable selects. appearance: base-select on the select and on select::picker(select) lets a page style the picker itself, and MDN documents a button containing a selectedcontent element as the markup for it. Support varies by browser, so check the browsers your audience uses before you rely on it.
A checklist for the Figma side
- Compare widths. Place the import next to the live page and measure fields that should match. If they differ, read the page's
box-sizing. - Read the fonts. Click a placeholder, a button label, and a select value. Confirm each font against the page's inheritance rules.
- Add states by hand. Draw hover, focus, checked, disabled, and error states as variants. One import captures one state.
- Redraw browser-drawn widgets. Date pickers, color pickers, range tracks, progress bars, and open select lists need your own design.
- Check generated content. Look for arrows, icons, and labels added through
::beforeor::after. - Name the layers. Rename the layers to "Input / Default", "Button / Primary", and so on, so the file reads as a form system.
When the checks are done, clean up the import and build a design system from the imported site so that the inputs and buttons you fixed become reusable components. If you are bringing the form in with UnHTML, the homepage lists the supported capture methods.
Conclusion
Boxes carry over. Browser-drawn internals don't. Text inputs, textareas, and buttons are styled rectangles and should arrive as layers you can edit. Selects, pickers, sliders, and meters rely on UI the browser owns, so redraw them and treat any tool that promises otherwise with suspicion.
Questions
- Why does a select look different from the other fields on an imported form?
- A traditional select is drawn partly by the browser, and CSS cannot reach its open popup. The closed box follows the box model, font, and appearance, so it can match your fields. The open list is the part you will need to design yourself.
- Should I design the buttons from input type=submit or button?
- MDN recommends button for styling. In Chrome an input type="submit" does not inherit its font from the parent and uses system-ui, so its text can differ from the rest of the form.
- What happens to a checkbox when appearance is none?
- It can become invisible while staying interactive, so a page that uses it must draw its own indicator. In Figma you design that indicator as a separate state.
- Can I trust the field widths on an imported form?
- Compare them to the page. Each widget has its own default border, padding, and margin, so equal declared widths can render at different sizes unless box-sizing is set.