How to Keep Rise Videos on the Final Frame with Mighty

Are you a tinkerer in Rise? If you enjoy experimenting with custom code to make targeted tweaks to your courses, this tutorial is for you.

End Videos Your Way in Rise: Customize How Videos Finish with Mighty’s Custom Code!

In native Rise, when a video finishes, it immediately jumps back to the first frame. With Mighty’s Custom Code, you can override it so the video stays on its final frame while still behaving like a normal Rise video block.

The Rise video behavior you’re working around#

In a standard Rise video block, the learner can watch the full video, the progress bar reaches the end, and then the visual frame resets to the beginning.

In the walkthrough, John uses the default beach video you see when you add a Rise video block. The video should end looking out at the horizon. Instead, as soon as playback completes, the frame jumps back to the opening shot—even though the progress bar still shows the video is complete.

That matters when the final frame carries instructional value, such as:

• A summary slide
• A completed process diagram
• A final state learners need to compare against
• A callout or reminder
• A “pause here and discuss” moment

If the frame resets, that last piece of information disappears at exactly the moment you want learners to sit with it.

Why Rise does this#

This isn’t a bug in your video file. It’s intentional Rise logic.

In the video, John shows that Rise runs code when the video ends. That code is trying to do a few things:

• Show the poster image
• Bring back the large play button in the middle
• Reset the video’s currentTime back to 0

That last part is the issue. When currentTime gets reset to zero, the player visually returns to the first frame.

The confusing part is that the learner has finished the video. The completion state is true. The progress bar is at the end. But visually, the frame goes back to the beginning.

Mighty’s approach is to intercept that end-of-video behavior and leave the player on the last moment of the video instead.

What Mighty’s Custom Code changes#

Mighty adds a Custom Code area inside the Theme tab where you can add JavaScript to your Rise course. In this case, the script listens for Rise video blocks, detects when a video ends, and prevents the Rise reset logic from firing, all without breaking the normal Rise completion behavior.

In the walkthrough, after the custom JavaScript is added:

• The video stays on the final frame
• The big play button returns
• There’s no awkward flashback to the beginning
• The Continue button still unlocks when the video finishes

You’re not trading clean visual behavior for broken course progression. The learner still completes the video, and Rise still lets them move forward.

Step-by-step: Keep a Rise video on its final frame#

Here’s the workflow shown in the video.

1. Open your Rise course with Mighty enabled.
2. Go to the Theme tab.
3. Open Custom Code.
4. Expand the JavaScript section.
5. Paste in the JavaScript provided with the Mighty video.
6. Decide whether the code should affect every video block or only specific video blocks.
7. Click Save.
8. Preview the lesson and test the video all the way to the end.

When it’s working, the video should stop on the final frame instead of jumping back to the first frame.

How the JavaScript works#

You don’t need to become a JavaScript developer to use this workaround, but it’s helpful to understand what the code is doing—especially if you’re handing a course off to another designer or QA reviewer.

The script uses a Mutation Observer.

That sounds technical, but the idea is straightforward: it watches the page for changes in the HTML. When new content appears, it checks whether any new video elements have been added.

That matters because Rise courses behave like single-page applications. Video elements may not exist in the page HTML until the learner actually reaches a specific lesson, passes a Continue button, or reveals that part of the course.

So the script can’t just look once when the course loads. It needs to keep watching.

When it finds a video that has not already been modified, the script marks it as modified and attaches a listener for the video’s end event. When the video ends, the script stops Rise’s default reset behavior and sets the video to the very last fraction of the video—specifically the final 0.1 second—so the final frame remains visible.

That tiny adjustment is what keeps the player parked at the end instead of snapping back to the start.

Apply it to every video—or just one block#

You have two options.

You can leave the targeting list blank, which applies the behavior to every video block throughout the course. This is a good fit when your course uses video consistently and you want every video to remain on its final frame.

Or you can target specific video blocks.

To do that, go to the lesson with the video block you care about. Mighty reveals block ID indicators in the editor. From there, you can copy the block ID, including the quotes, and paste it into the list in the script.

You can also use the copy icon Mighty provides for the block ID. If you do that, John notes that you can remove the data-id portion with the square brackets and keep the block ID itself.

If you need to target multiple video blocks, use a comma-delimited list of the block IDs you want the script to affect.

This is a small but useful move. You may want one video to reset to the beginning because it functions like an intro or loop, while another video needs to stay on the final frame because it ends with a summary graphic.

When this is worth using#

This is especially helpful when the final frame is designed intentionally.

For example, you might use it when a video ends on:

• A completed software screen
• A safety checklist
• A process map
• A final answer reveal
• A reflection prompt
• A summary slide that reinforces the learning point

Without the override, learners may only see that frame for a split second. With it, the frame remains visible long enough to support the learning moment.

It’s also helpful for stakeholder reviews. If your SME expects the video to end on a branded takeaway screen, having Rise snap back to the first frame can look like a production mistake—even when it’s just native player behavior.

A quick QA note before you publish#

After you add the JavaScript, preview the course and test the full learner path.

At minimum, check that:

• The video reaches the final frame and stays there
• The large play button appears again
• Any Continue button unlocks as expected
• The behavior works after navigating away and back
• Any targeted block IDs are applied to the correct video blocks

If you’re using the code across every video block, spot-check multiple lessons—not just the first one. Because Rise loads lesson content dynamically, it’s worth confirming the Mutation Observer is catching videos as they appear throughout the course.

Why this matters for course design#

A video’s final frame is often part of the learning experience. It might be where you reinforce the main point, show a finished example, or give learners a visual cue before they continue. When Rise resets that frame, the course loses that moment.

Mighty doesn’t change how you build the Rise video block. It gives you a practical way to adjust how that block behaves at the end—without rebuilding the interaction somewhere else.

If your next Rise course includes videos with meaningful final frames, try using Mighty’s Custom Code to keep those frames visible. It’s a small change that makes the ending feel intentional.

👉 For more video hacks and custom video interactions, check out Mighty Studio.