Blog / Framer & site building /

Testing a framer plugin with real editor workflows

Demos are easy. The example page is tidy, every field is filled in, and the plugin glides through it.

Real projects aren’t like that. There’s the CMS entry with no image. The title that wraps across three lines. The editor who opens the panel halfway through something else.

I can’t share client details, but the testing lesson applies to any editor tool: test the real workflow, not just the happy path.

Watch the task from beginning to end

Write down what the editor is trying to accomplish before opening the plugin. What do they select? What information do they already have? Where do they expect the result to appear? A tool that interrupts the task to ask for the same information again may be solving the wrong problem.

Use a representative project and observe someone working through it if possible. Let them explain where they hesitate. Avoid coaching them through the interface; the confusion is part of the evidence.

Test the awkward inputs

Try missing values, long text, unusual characters, empty collections, pages with different templates and content that changes after the plugin opens. Test permission limits and network failures if the tool depends on external data.

When something fails, the message should explain what happened and what the editor can do next. “Error” isn’t a recovery path. I’d rather write one extra sentence of help text than leave an editor guessing.

Check that the result is safe to use

If the plugin makes or suggests an edit, confirm exactly what it changes and whether the editor can review or undo it. Avoid overwriting content silently. Test that links, metadata or other outputs remain valid after the underlying page changes.

Learn from a small test before expanding

A short usability session can reveal label problems, missing context or unnecessary steps. Record the issue and the conditions that produced it. Don’t turn one person’s preference into a universal rule. Look for friction that repeats.

Test variation, recovery and access

Run the same task with different permissions and document states. Try a page with the expected component, one with a missing label and one with a custom component the plugin does not recognise. Observe how an editor understands each result. A useful test records the exact step, the expected behaviour and the actual behaviour rather than simply saying that the plugin worked.

Check keyboard use and focus as well as the visual panel. Editors should be able to reach controls, understand notifications and return to their work without losing context. Consider whether the plugin needs network access; if it does, explain what information is transmitted and why. If the check can run locally, avoid adding unnecessary external dependencies.

Finish by writing a small acceptance note with supported cases and known limits. That gives the client a realistic basis for adoption and a reference when the editor changes.

Observe the task without coaching

Give an editor a realistic task and ask them to think aloud while using the plugin. Do not explain where every control is before the test; the moments of hesitation are part of the evidence. Record whether the result answers the question they had, whether the next action is clear and whether they can recover from a mistake. Ask them to repeat a task with a different component so you can see whether the behaviour is consistent.

Test an interrupted workflow too. Close the panel, switch pages, reopen the file and return to the check. A tool that only works in the perfect sequence may be frustrating in normal project work. Check that progress is not lost unexpectedly and that any cached result makes clear when it was last evaluated.

After testing, sort observations into defects, confusing copy and feature requests. Fix a broken core task before polishing small preferences. Keep the acceptance criteria tied to the client’s actual workflow so the project does not expand into an unbounded tool build.

Record the editor’s words as well as the actions they take. A control that technically works may still have a label that suggests the wrong outcome. Update the interface language when the test reveals that gap, then repeat the task with someone who has not seen the revised version.

After the test, share a short summary with the client: the tasks covered, the observed issues, the supported cases and what remains outside scope. This keeps expectations aligned and gives the team a clear basis for deciding whether to proceed with installation.

Include the test date and editor version in the notes. This makes it easier to distinguish a regression from a change in the editor itself when someone repeats the workflow later.

Don’t use a client’s production file as the only test environment. I always work from a safe copy first. Keep a safe copy or representative project so experiments do not risk disrupting live editorial work.

Check that the plugin’s warnings remain understandable when there are several findings. Group related issues and avoid presenting minor suggestions with the same urgency as a blocking defect.

Make the test repeatable

Turn the observations into a small test plan that someone else can run after a plugin update. State the starting page, the content or component to use, the action to take and what a correct result looks like. Keep expected results concrete: for example, the editor can see which item failed and can return to the same page without losing their place. This gives a useful comparison when the interface or Framer itself changes.

Separate usability findings from defects. A broken control needs a fix; a label that several editors misunderstand may need clearer wording; a request for a new workflow may belong in a later scope discussion. Capturing those separately keeps the response proportionate and helps the client decide what must be resolved before release.

Before handing the plugin over, check the tested version and note any assumptions about permissions, page structure or network access. If one of those assumptions changes, repeat the relevant test rather than treating the old result as proof. A concise record is enough to make the next review useful.

Before you rely on any plugin, yours or someone else’s, pick one real editor task and watch someone complete it without help. Where do they hesitate?