Design a Branching Conversation Lab in Rise

A strong scenario block doesn’t just ask learners what they know; it lets them feel the consequence of a choice while they’re still safely inside the course.

Design Challenge with The eLearning Designer's Academy: The De-escalation Lab

That’s what makes Mighty user Priyanka’s De-escalation Lab such a useful model for Rise designers: it turns a difficult manager conversation into a compact, practice-first simulation with context, branching choices, visible stakes, and feedback that arrives in a believable way.

What this build does differently#

The challenge—posed by The eLearning Designer's Academy— was to create a new Rise block template using Mighty Studio that gets learners into the practice side of a course. Not another content display. Not a prettier knowledge check. A block where the learner has to act.

Priyanka’s entry does that by dropping the learner into a familiar workplace moment:

• You’re a manager starting your workday.
• An email alert tells you that an team member, Alex, filed assets for a sales training launch incorrectly.
• Alex didn’t use the standard templates or naming conventions again.
• The mistake will take roughly 15 hours to reset before another team member can begin work.
• You have a one-on-one with Alex starting in five minutes.

The task is simple, but loaded: address the issue with Alex while keeping defensiveness low and trust high.

That gives us a helpful blueprint for building our own conversation lab in Rise.

Step 1: Start with a real pressure point, not a topic#

Before you build anything in Mighty Studio, define the situation the learner is walking into.

In the De-escalation Lab, the learning moment is not “communication skills” in the abstract. It’s a specific management pressure point: you need to correct a team member’s behavior without triggering a defensive response.

Use this structure for your own scenario:

1. Name the learner’s role.
2. Name the person they’re interacting with.
3. Create a time constraint.
4. Make the business impact visible.
5. Give the learner one clear goal.

For example, Priyanka’s version effectively says:

You’re the manager. Alex made a process mistake that affects the project timeline. Your one-on-one starts in five minutes. Address the issue while keeping defensiveness low and trust high.

That goal matters because it gives the learner something to optimize for beyond “pick the nicest answer.” They’re managing a relationship and a work outcome at the same time, which is exactly why the practice is valuable.

Step 2: Build the simulated workspace around the learner#

One of the best parts of the De-escalation Lab is how quickly it feels like the learner is inside their own work computer.

The opening screen includes familiar workplace cues:

• An email notification about Alex’s sales training launch files
• A Teams-style meeting reminder
• A simulated desktop/workspace layout
• A prompt to join the upcoming one-on-one

This is a good use case for Mighty Studio because you can create a custom Rise block that feels purpose-built instead of trying to force the interaction into a standard Rise block pattern.

For your own version, sketch the screen as a sequence of panels:

1. Workspace frame: the visual container that makes this feel like a desktop or work app.
2. Trigger notification: the message that introduces the problem.
3. Time pressure cue: a reminder that the conversation is imminent.
4. Action button: the learner’s next move, such as joining the meeting.

Keep the interface focused. You don’t need to recreate an entire operating system. Priyanka’s build works because the details serve the scenario: email, meeting reminder, and the upcoming conversation.

Step 3: Give the learner a clear objective before the first choice#

Before Alex speaks, the simulation reminds the learner of the objective: address the issue while keeping Alex’s defensiveness low and trust high.

That short instruction does a lot of work.

It tells the learner what success looks like, and it sets up the feedback system they’ll see during the conversation. In this case, the key measures are not quiz points. They’re the human dynamics of the conversation:

• Defensiveness
• Trust

If you’re building a similar scenario, choose two variables that match the skill being practiced. For example:

• Psychological safety and clarity
• Confidence and confusion
• Urgency and reassurance
• Buy-in and resistance

Try not to track too many things. Two visible tensions are usually enough for a short Rise interaction, especially if the learner is making choices quickly.

Step 4: Write answer choices as conversation moves#

In the video walkthrough, Alex joins the call and says:

“10 minutes before my client sync on the flagship project. What’s up?”

The learner then chooses how to respond. The options are framed around tone and strategy, not just content.

One demonstrated path uses a directive and firm approach. Alex immediately reacts defensively:

“Oh, clear defensiveness. So my track record here doesn’t matter. Just compliance with rigid templates. Got it.”

That’s intentional scenario writing. The choice is not labeled “wrong” in a generic way. The learner sees the interpersonal consequence in Alex’s response.

As you draft your own choices, write each option as a different conversational move:

1. Directive and firm: states the expectation quickly, but may heighten threat.
2. Validate and show curiosity: acknowledges the concern and asks for more information.
3. Rebut the metaphor: argues with the learner’s framing, likely escalating tension.
4. Minimize the concern: makes the other person feel dismissed.

Priyanka’s scenario includes a strong example of the validate-and-curiosity option:

“So it’s less about disliking rules and more about the design ceiling they put on your work. Tell me more about which parts actually get in your way.”

That line works because it does two things at once: it reflects Alex’s concern and invites specifics. It’s still moving the conversation forward, but it doesn’t start with a power struggle.

Step 5: Let the learner experience a bad path#

A useful branching scenario should make the less effective path instructive, not just punitive.

In the video, Brianna—senior LXD at Maestro—intentionally chooses the “bad boss” route to show what happens. After selecting a minimizing response—“every job has paperwork”—Alex escalates:

“Paperwork, right? My design system is just paperwork. Good to know where craft ranks here.”

Then Alex ends the call:

“You know what? This isn’t a dialogue. It’s a lecture. And I have a client waiting. I’m going to drop. Send me whatever you need signed off.”

That moment lands because the simulation does not interrupt with a generic “Incorrect.” It lets the conversation fail in a realistic way.

When you’re writing your own branches, resist the urge to explain too early. Let the character’s response carry the feedback first. Then add reflection after the learner has felt the consequence.

Step 6: Deliver feedback through the same world you created#

Here’s the fun part of Priyanka’s build: after the failed conversation, the feedback arrives as a new urgent email from HR.

The message explains that Alex left the one-on-one midway through and submitted a resignation letter later that afternoon.

Then the simulation breaks the fourth wall just enough to teach the principle:

“When defensiveness maxes out, people stop hearing content entirely. The meeting ended the moment the threat response took over.”

That feedback is effective because it has two layers:

• In-world consequence: Alex resigns, and HR escalates the issue.
• Instructional takeaway: defensiveness blocked the actual message.

For your own Rise block, consider how feedback could arrive naturally inside the scenario environment:

• An email from HR
• A chat message from a peer
• A customer follow-up
• A project status update
• A manager debrief
• A calendar invite being canceled

This keeps the learner immersed while still giving them the coaching they need.

Step 7: Show the outcome based on what the learner actually did#

The video walkthrough points out that the review message reflects the choices made during the conversation. That’s an important design detail.

If the learner drove defensiveness to the maximum, the outcome should say that. If they maintained trust, the outcome should reflect that too.

You can structure your end state with three parts:

1. What happened: the immediate consequence in the scenario.
2. Why it happened: the behavioral pattern behind the outcome.
3. What to try next: the next strategy the learner should practice.

For example, on a failed path:

• Alex left the conversation.
• The issue stopped being about templates and became about threat and respect.
• Next time, validate the concern before restating the standard.

On a stronger path, the feedback might reinforce how curiosity lowered defensiveness enough to discuss expectations.

Step 8: Make it reusable as a scenario template#

Brianna notes that this structure could be repurposed for many conversation types while keeping the same core design:

• A simulated workplace environment
• Notifications that set up the scenario
• A live conversation with branching responses
• Relationship-based measures like trust or defensiveness
• Feedback delivered through email or another workplace channel

That’s the real design opportunity. Once you have the pattern, you can adapt it for coaching, customer service, performance feedback, compliance conversations, change management, or peer conflict.

The content changes, but the practice engine stays familiar.

A quick accessibility and design note#

Immersive simulations can get busy fast. Priyanka’s build uses familiar workplace cues, but the learning goal stays clear: manage defensiveness and trust during the conversation.

As you build your own version, keep these guardrails in mind:

• Don’t rely on sound alone to deliver important dialogue or feedback.
• Make the goal visible before choices begin.
• Keep on-screen notifications readable and purposeful.
• Avoid adding decorative workplace clutter that competes with the decision.
• Make sure feedback is available as text, not only as a visual state change.

A realistic interface is helpful only if it supports the learner’s decisions.

The takeaway#

The De-escalation Lab is a great reminder that a custom Rise block does not have to be flashy to be powerful. It needs a believable situation, meaningful choices, and feedback that shows the consequence of the learner’s behavior.

Try using this pattern the next time your course needs more than “read and remember.” Build a small lab where learners can practice the moment that actually matters.