Blog / Framer & site building /
Useful documentation for a no-code website component
The component works perfectly in the demo. Then someone drops it into their own project, changes one setting, and it vanishes on mobile. Now they’re reverse-engineering something they just bought.
A small website component can be flawless in a demo and still frustrate the person who has to install it, style it and fix it later. What’s missing usually isn’t another feature. It’s documentation that answers the question they have at the exact moment they get stuck.
No-code tools let you build fast, but “no code” doesn’t mean “no explanation”. A component might rely on a particular property, breakpoint, CMS field or interaction setting. If that requirement only lives in the creator’s head, your user has to dig it out themselves.
Explain the component before the setup
Start with one plain sentence: what the component does and who it suits. Don’t describe the internals before the reader knows whether it fits their project. Mention important limits early: a browser requirement, a supported layout, a required CMS field, or a feature that isn’t included.
Show a preview of the finished result and point out what’s adjustable. A visual example gives the reader a target. If the component changes across breakpoints, show it on a narrow screen too. A polished desktop preview shouldn’t imply every layout is supported.
Then give the shortest path to a working setup. What to copy or insert, where it goes, which settings to change and what the user should see afterwards. If a step refers to a property, use the exact label from the interface. Tiny mismatches between docs and editor are brilliant at making people doubt themselves.
Make assumptions explicit
Components make assumptions about where they live. One may expect a parent container of a certain width, a particular layer order, a published site, or data in a specific shape. State those assumptions before the troubleshooting section. If it relies on third-party code, say what that code does and where it loads.
Separate required settings from optional customisation. Nobody should have to guess which colour control makes the component work and which one just changes how it looks. A short “required” list followed by an “optional” list beats one long mixed list of every property.
Explain what happens when a value is left blank or entered wrong, if that matters. Don’t claim it works on every device or browser unless you’ve checked. A precise limitation is more useful than a vague compatibility promise. I’d rather read “tested in Chrome and Safari” than “works everywhere”.
Use examples that teach, not decorate
A good example shows an ordinary use with realistic content. If the component displays a card, use a title that could actually appear on a website and say which setting controls it. If there are variants, show the difference and when you’d pick each.
Don’t rely on screenshots alone when a short text label would let people search the page or follow along. Screenshots date quickly and can be hard to read. Use them for visual states, but keep the essential steps in text, so people can skim, search and use assistive technology.
If users need to paste code or a custom snippet, say where it goes, what it changes and how to remove it. A code block with no context isn’t self-service documentation. It’s an invitation to hope for the best.
Plan for the first failure
Document the likely troubleshooting steps. Did they copy the whole component? Set the required properties? Publish the page? Test the right breakpoint? Explain how to reset a setting or go back to the original. If there’s a known limitation, put it here, instead of letting people chase a feature that doesn’t exist.
Tell users how to report a problem and what to include: the platform, expected versus actual behaviour, steps to reproduce, and a screenshot if appropriate. Never ask for passwords or confidential project access. A reproducible report is far more useful than “it doesn’t work”, and it improves the docs as well as the component.
Keep the instructions beside the product
Put the docs where people find them before and after installing. Link from the listing, the onboarding message or the project file. If the platform changes its interface, revisit the screenshots and labels. When you fix a bug, update the instructions in the same release, so the docs never describe an older version.
Then ask someone who didn’t build it to follow the guide from a clean project. Watch where they pause, guess or backtrack. That’s better evidence than the creator’s feeling that it’s all obvious. Whenever I write instructions for anyone, this is the test I trust most, because I can never see my own gaps.
Make version changes visible
When behaviour can change, say which version the docs describe. If a platform update moves a setting, add a short note or fix the step, instead of leaving users to compare old screenshots with a new interface. When the component itself changes, say whether existing installs need updating or whether the new steps only apply to fresh projects.
Keep one canonical documentation page and link to it everywhere the component appears. Instructions copied into a marketplace description, an email and a project file drift apart. A short summary can live in several places, but detailed setup steps should point to the maintained source. That also gives you one place to fix a mistake fast.
When a user reports a problem, update the guide if the report reveals a gap that could catch others. Thank them, and don’t present a one-off fix as a guaranteed solution. The clearest docs reflect real use and known limits, not just the creator’s ideal setup.
Related reading
- Testing a Framer site across CMS and static pages
- A Framer launch checklist for designers
- Framer page speed and third-party scripts
So, what’s the first question a new user asks when setting up your component? Does your documentation answer it before they have to ask?