Ship Shape-

Smooth sailing

For every guest.

A branching eLearning module where cruise line guest services agents balance customer relations with policy limitations.

The module trains agents to stick to policy, even when guest's attitude makes bending the rules feel like the easier call.

Role
Instructional Designer
Audience
Hospitality Industry
Platform
Articulate Storyline 360
Problem

The policy was the same for every guest. Whoever pushed hardest got the exception.

The conceptual client, a mid-size cruise line, saw satisfaction scores swing wildly ship to ship, even with every agent trained on the same policy. The issue wasn't knowledge. Agents knew the rules and still folded once a guest pushed hard enough. Pushy guests got extra perks. Quiet guests got exactly what the manual said. Same problem shows up anywhere staff hand out perks based on status, not just cruise lines.
Solution

Agents didn't need more rules to follow. They needed practice staying steady while still hearing the guest out.

A better cheat sheet seemed like the obvious fix, but one already existed. That was never the problem. Agents just stopped reaching for it once a guest got emotional. So I built a branching scenario module instead, where agents have full access to guest policy and work through guest conversations and get coached afterward by a supervisor character. Make the call, see what happens, try again with the next guest. That's closer to how people actually learn to hold their ground rather than memorizing rules.
Learning Objectives
By the end of this module, learners will be able to:
- Apply tier-based policy correctly, even as guest pressure escalates
- Tell the difference between a guest's tone and what they're actually entitled to
- Use the tools they'd have on the job instead of trying to memorize everything
- Bounce back from a bad call on one guest instead of repeating it with the next

My Process

How a plan and an action map turned into an actual scene-by-scene script.

Text-based Storyboard
03
What the research revealed

Every guest conversation comes down to a choice between three responses, scored as Best, Fine, or Incorrect, since real guest service is rarely a clean right-or-wrong. Whatever the agent picks, the guest reacts to it before the module moves on, so the choice has a visible consequence instead of just a score ticking up or down somewhere unseen. After that, Ryan steps in with a short, specific note on what worked or what didn't. He's coaching, not grading.

Action Map
02
Steps to reach end goal

Each guest represents a different way this policy breaks down in real life, starting with a simple case any agent should get right, and ending with Lucia, a guest built specifically to not have an obvious answer. She's the one meant to make an agent actually think instead of guess.

Plan
01
Steps to reach end goal

I started by figuring out the specific ways agents were getting this wrong, and built four guest personas around those patterns, going from a clean, obvious case up to a real gray-area guest where there isn't an obviously right answer. From there I built the branching logic and scoring, designed the visuals, and put the whole thing together in Storyline, going back through the debriefs and feedback more than once until the coaching actually felt like coaching. I didn't have an outside subject matter expert on this one. Instead I leaned on ten-plus years of working in applied behavior analysis, where you learn pretty quickly that knowing a rule and following it under pressure are two different things.

Step 01
Action Map
Mapped out how judgment breaks down under guest pressure, and built four guest personas around those patterns
Step 02
Text-based Storyboard
wrote out each guest conversation, the branching choices, and supervisor debrief for every decision
Step 03
Visual Mockups
Designed the interface, including the progress bar, tier reference panel, and character art
Step 04
Development
Built the full module in Storyline, with scoring variables feeding into the final report card
Development
05
Color as a deliberate trust signal

In Storyline, each guest's score is tracked as its own variable, feeding into a final report card. If an agent gets a question wrong, the module doesn't stop or throw up a hard "incorrect" screen. It just keeps going, so one bad call with one guest doesn't tank the whole experience or make someone want to quit halfway through. At the end, the report card breaks down how the agent did across all four guests, points out where things went sideways, and lets them retry for a better score if they want. The ending is one more coaching moment, not a final verdict.

Visual Mockups
04
From findings to direction

A progress bar at the top shows how far the agent is from the next guest and from the end, so there's always a sense of how much is left instead of it feeling open-ended. Each guest conversation is short on purpose, one concern at a time, so the agent's attention stays on the decision instead of getting lost reading. Help and the tier reference panel are available the whole time, because the point was never to test memorization. It's to build a habit of checking the reference and still making the right call while a guest is in front of you, which is what the job actually looks like. Text and background colors were checked for contrast against WCAG guidelines, and buttons and the reference panel have clear hover states so it's obvious what's clickable.

Design Decisions

Every visual and technical choice was designed to keep users thinking, not memorizing.

Outcome

The finished module, and what building it taught me about designing for judgment instead of recall.

Results & Takeaways
07
What was learned

Working on this sharpened my Storyline skills, especially branching logic and variable-based scoring. But the bigger thing I took away was a clearer sense of how I think about instructional design: as a behavior problem first, not just a content problem.

Design Process
I approached this the same way I'd approach any performance issue: figure out what's actually breaking down before designing anything. Mapping out the four guest types before writing a single line of scenario dialogue kept the whole thing focused, and it made building the module faster since every decision had a clear reason behind it. If this were a real deployment, I'd track it by looking at guest satisfaction scores and how consistent agents were across ships before and after rollout.
Coaching over Correcting
Building Ryan's debrief taught me how much tone matters. If a module just tells someone they got it wrong, they tune out. If it explains why and coaches them toward a better answer, they actually stick with it. That distinction shaped every debrief in the module.
Behavior-Based Starting Point
My background in applied behavior analysis is really where this whole project started. Instead of asking what agents need to know, I asked what makes them abandon something they already know the moment a guest pushes back. That question shaped the personas and the debriefs, but it stayed in the background. The instructional design work is the point of this project, not the behavior analysis background behind it.
Next Steps
This was a solo project, built without a subject matter expert or feedback from actual agents. Before rolling this out for real, I'd want to test it with a small group of guest services agents to see if the scenarios actually match what they deal with, and whether the coaching changes how they handle a guest on the floor. I'd adjust the personas and feedback based on what that turns up.
Final Project
01
Branching instructional design module