DEV Community

Cover image for The Rive Handoff Checklist: 10 Things Developers and Animators Should Agree On Before the First Keyframe
Maxim Tincu – Rive Animator
Maxim Tincu – Rive Animator

Posted on Edited on

The Rive Handoff Checklist: 10 Things Developers and Animators Should Agree On Before the First Keyframe

Rive is great at one thing Lottie and video can't do: the animation reacts. A button knows it's hovered, a mascot knows the user got the answer wrong, a progress ring knows it's at 73%.

But that power comes with a catch. A Rive file is not just artwork anymore. It's a small piece of your app's logic, and it has an API. And like any API, it breaks when the two sides didn't agree on the contract first.

After 10+ years in motion design and a lot of Rive projects for product teams, I've noticed the same thing again and again: almost every "the animation doesn't work" message I get is not a bug. It's a missing agreement.

So here's the checklist I go through with developers before I start animating. Steal it for your next project.

1. State machine name

Your code loads the state machine by its exact name. State Machine 1 (the default) works, but it's easy to rename later and silently break everything.

Agree on one clear name early, for example Mascot SM or Button SM, and don't change it without telling each other.

2. Input names and types

This is the big one. Write the inputs down like an API spec:

  • isHover (Boolean): the pointer is over the element

  • isPressed (Boolean): the element is being pressed

  • success (Trigger): plays the celebration once

  • progress (Number, 0–100): fills the progress ring

Names are case-sensitive. isHover and IsHover are two different inputs, and the runtime won't warn you loudly when you get it wrong. You'll just get… nothing.

3. Who owns the logic?

Decide what lives in the Rive file and what lives in your code.

Inside Rive: transitions, blending, idle loops, "after the celebration go back to idle".
Inside your app: when something happens (API response, user action, timer).

A simple rule that works: the app sends facts ("the answer was correct"), the Rive file decides how it looks. That way the animator can improve the motion later without touching your code.

4. Inputs vs. Data Binding

Newer Rive runtimes support Data Binding (view models), which is often a cleaner way to push data like text, numbers and colors into an animation than wiring up lots of separate inputs.

Before work starts, check which runtime version your app uses and agree on one approach. Mixing both "because the file had it" is how projects get messy.

5. Artboard size and how it should scale

Tell your animator where the animation will live: a 48px icon, a full-width hero, a card on mobile?

Then agree on the fit and alignment you'll use in code (Contain, Cover, Fill, etc.). An artboard designed for Cover will look cropped if you render it with Contain, and the other way round.

6. Default state on load

What should the user see in the first frame? This matters more than people think, because it's what shows while everything else loads.

Agree that the state machine starts in a clean, meaningful idle state, not halfway through an intro animation.

7. Events coming back to your app

Rive can also talk back to your code with Rive Events, for example "the celebration finished" or "the user clicked the mascot's hat".

If you need to know when something ends (to show the next screen, play a sound, log analytics), ask for an event. Don't guess the duration with a setTimeout. The day the animator makes the motion 200ms snappier, your timing breaks.

8. Text and fonts

If the animation contains text that changes (a username, a score, a translated label), say so up front. Runtime text needs to be set up differently than text that's baked into the artwork, and embedded fonts add to the file size.

Also think about localization: German words are long. Make sure the layout survives them.

9. File size and performance budget

Rive files are usually tiny, but they can grow with embedded raster images, fonts and lots of artboards.

Give your animator a budget (for example "under 150 KB for the onboarding mascot") and the lowest device you need to support. It changes how the file gets built.

10. A test page before the real integration

Before the file goes into the app, I always share a quick preview where the developer can toggle every input and fire every trigger by hand.

It takes minutes and catches most problems: wrong input names, transitions that never fire, states that get stuck.

What the integration looks like when the contract is clear

Here's a minimal React example using @rive-app/react-canvas. Notice how little code there is when the names were agreed on in advance:

import {
  useRive,
  useStateMachineInput,
  Layout,
  Fit,
  Alignment,
} from "@rive-app/react-canvas";

const STATE_MACHINE = "Button SM";

export default function RiveButton({ onClick }) {
  const { rive, RiveComponent } = useRive({
    src: "/animations/button.riv",
    stateMachines: STATE_MACHINE,
    autoplay: true,
    layout: new Layout({ fit: Fit.Contain, alignment: Alignment.Center }),
  });

  const isHover = useStateMachineInput(rive, STATE_MACHINE, "isHover");
  const success = useStateMachineInput(rive, STATE_MACHINE, "success");

  return (
    <RiveComponent
      style={{ width: 240, height: 80, cursor: "pointer" }}
      onMouseEnter={() => isHover && (isHover.value = true)}
      onMouseLeave={() => isHover && (isHover.value = false)}
      onClick={() => {
        success && success.fire();
        onClick?.();
      }}
    />
  );
}
Enter fullscreen mode Exit fullscreen mode

Three names (Button SM, isHover, success) and the whole thing works. Get one letter wrong and nothing happens. That's why the checklist exists.

The copy-paste version

Send this to your animator (or developer) before the project starts:

RIVE HANDOFF AGREEMENT

  • State machine name:
  • Inputs (name / type / purpose):
  • Inputs or Data Binding? Runtime + version:
  • Logic owned by Rive / owned by app:
  • Artboard size + Fit/Alignment in code:
  • Default state on load:
  • Events needed back in the app:
  • Dynamic text / fonts / languages:
  • File size budget + lowest target device:
  • Preview/test page before integration: yes

Ten lines, ten minutes, and you'll skip most of the back-and-forth that makes Rive projects drag on.

Need a Rive animator who works this way?

I'm Maxim, a Rive animator and motion designer with 10+ years of experience and 100+ projects. I create interactive mascots, animated logos and icons, UI micro-interactions and onboarding animations, and every file comes with clean, documented inputs your developers can plug in right away.

👉 See my work and get a quote at hireriveanimator.com

Questions about your own Rive setup? Drop them in the comments and I'll answer.

Top comments (0)