Unannounced Project | Designer Advocacy in Pipeline Development

TL;DR

Challenge: 50+ manual import steps per scene delayed playtesting and pulled designers away from feature work.

Solution: Advocated for designer-focused automation, then validated workflow improvements through hands-on production testing.

Impact: Reduced import from 50 steps to 5, enabling one designer to import all 40 game scenes—scope that previously required multiple people.

**The script import pipeline: moving data from Playwrite (script authoring) through Storyteller (cinematic tool) into Unreal Engine.**

Situation

At Deck Nine, getting a script from the writer's screen into playable content requires moving data through three interconnected tools: Playwrite (our script authoring software), Storyteller (our in-house cinematic tool), and Unreal Engine. For our previous title, this process was documented at over 50 steps per scene.

Each import required manual creation of hotspot actors in Unreal, copying object tags character-by-character to match them in Storyteller, placing characters, configuring data layers, and validating connections across all three tools. Typos in object tags broke interactions. Forgetting to check a single box in data layer settings prevented scenes from loading. Missing a step in the sequence meant retracing everything to find the break.

I'd experienced these pain points during the Hotspot Polish strike team on Life is Strange: Double Exposure, where we spent late production manually correcting hundreds of interaction points. The volume of manual work created a strategic bottleneck: designers couldn't reach playable state fast enough to validate logic, test pacing, or catch design issues when they were cheapest to fix.

When development began on our next project, the studio initiated D9Sequencer development to modernize our pipeline. While the Cinematics team led the charge on moving to native Unreal level sequences, a gap emerged: no one had addressed how Design would manage scene logic, hotspot workflows, and other needs outside pure cinematic work.

Task

While the primary focus remained on cinematic pipeline improvements, I represented Design ensuring the tool had cross-department functionality from the beginning. My role centered on three objectives:

Document existing pain points from a designer's perspective to inform automation priorities
Provide weekly testing and feedback to catch workflow friction engineering couldn't anticipate
Validate the improved process at production scale by importing scenes for the full game

This wasn't about building the tool—our Sequencer team handled technical development (including Damien, Mark, Nick, Scott, Todd, Tom, Andres, Kaity, Jason, and others I'm certainly missing). My contribution was ensuring it solved real designer problems.

**Each phase of the old import workflow documented separately—the foundation for identifying automation priorities.**

Action

Documenting the Baseline

I spent a full week documenting the old import workflow—not because individual steps were complex, but because the sheer volume created a maze of dependencies and failure points. This documentation became the roadmap for automation conversations.

Weekly Advocacy

In Sequencer team meetings, I translated designer pain into specific feature requests:

Automated Hotspot Creation: Generate hotspots with object tags pre-matched to Storyteller, eliminating connection errors.
Grid Formation Placement: Arrange hotspots in a grid within the location volume instead of a single line, making placement manageable.
Non-Destructive Test Imports: Skip hotspots already in Unreal, letting designers set up infrastructure during test imports without losing work on final imports.
Search Features: Add tools for finding specific marker types across all level sequences in the main graph.

**Quality of Life tracking: Design team feature requests for D9Sequencer, including the sequence event search tool**

Production Validation

Once core automation was functional, I imported all 40 scenes over approximately five months. The faster process changed how I worked: instead of waiting for "final" scripts to minimize repeated imports, I ran test imports early in narrative development.

I spent the time saved on manual setup conducting logic passes—checking conditional statements, validating variable gates, ensuring branching paths made sense. This upstream work meant cleaner handoffs to other departments. When edge cases emerged (unexpected character blueprint generation, data layer misconfigurations), I documented them and worked with engineering to iterate on solutions.

Results

The workflow improved significantly:

90% Reduction in Import Steps: What required 50+ documented steps condensed to 5 core actions. A process that took a full week to learn became straightforward.
Single Designer Ownership: One designer owned all script imports for 40 scenes—scope that would have been impractical under the old system.
Time Shifted Upstream: Time freed from manual import tasks shifted to narrative logic work, ensuring scripts were cleaner before reaching downstream teams.
Earlier Design Focus: The design team could focus on gameplay tuning, narrative logic refinement, and player experience validation earlier in development than previous projects allowed.

Lessons Learned

Pitfall 1: "Imported ≠ Flexible"

Once a script was imported and passed to Cinematics, all future changes followed Change Management pipeline rules. A new import would overwrite all cinematic sequences created during the import. Building or adding content remained manual—lots of steps, room for mistakes.

This was inherent to how data moved from Playwrite → Storyteller → Unreal. We acknowledged the issue but couldn't solve it for the current project. It meant imports still had to be treated carefully despite being faster.

For instance, if a designer realized a NPC interaction needed to move to a different location after the import handoff, the change required manual actor repositioning, mocap grid adjustments, Storyteller updates, and coordination with multiple teams—despite the import process itself being "correct" and automated.

Despite automation improvements,new content added after import required manual sequence creation in both Storyteller (left) and Unreal (right).

Pitfall 2: Upstream Over-Commitment

Faster imports placed greater importance on the script. But it's hard to know how a scene will unfold from text alone—cool discoveries happen in-engine, unexpected challenges emerge.

By investing so much energy upstream, we sometimes over-committed to ideas that would have benefited from in-engine iteration before the script was written. Production timelines didn't allow for this exploratory work. Some complex scenes weren't worked on until weeks or even a month after they were written. By then, we didn't have bandwidth for changes—each narrative adjustment risked ripple effects in subsequent scenes and required manual work to implement.

For example, Scene X was imported in late August but wasn't implemented in-engine until mid-October. By then, we discovered a challenge with our timer puzzle setup — but couldn't adjust the script to account for the needed gameplay enhancements—each narrative change would ripple through subsequent scenes and require manual rework, which we didn't have bandwidth for. (After the project has been released, I'll be able to call out which scene and what puzzle)

Conclusion

This wasn't flashy feature work—it was infrastructure. The unglamorous, behind-the-scenes systems that determine whether teams can work efficiently or spend their time fighting their tools.

My role was specific: document pain points clearly, represent user needs in development conversations, and validate solutions through production use. Engineering built the technical solution. I made sure it solved the actual problem.

The result was a workflow that let me import 40 scenes for an entire game, something that would have been logistically impossible under the previous system. More importantly, it established a pattern—designer voice in pipeline development creates tools that work in practice, not just in theory.

Pipeline thinking isn't separate from design work. It's understanding that how we work shapes what we can build. Sometimes improving the team's workflow is the most impactful design contribution you can make.

From 50 Steps to 5: Improving Scene Import Workflow