As you may know, I’m a nerd at heart, and with that comes my love for tabletop games, especially Tabletop Role Playing Games (TTRPGs). For a while, I’ve been sitting on this idea of combining my two hobbies—TTRPGs and AWS!

To make it easier, I could have done some sort of sci-fi adventure, and it probably would have worked better than what I did…but I like a good challenge, so I went for a fantasy setting. Thus AWSia was born, an ancient world of Cloud Magic! Imagine explaining EC2 instances through warrior classes, or S3 buckets as mystical storage vaults. What started as a wild idea became a surprisingly effective way to make cloud concepts click for both newcomers and experienced cloud practitioners.

If you went to the community day in Lisbon last month, you had the opportunity to beta test this concept! The response was incredible—watching people have ‘aha!’ moments about cloud architecture while rolling dice (or a giant die in this case) made all the work worthwhile. But if you weren’t there, keep reading 😄

For this post, I want to show the ruleset I’m creating to run a fun and enjoyable adventure in the AWSia world while learning AWS concepts. I’ll present some pre-made characters and use them as examples in a small adventure I ran at the community day. I’ll give the full explanation of rules and how to create your own characters in a later post, so you can run the game yourself and teach AWS concepts with it!

Since this is a TTRPG adventure, you’ll need some dice! In this case, 1 D20 (20-sided die) and a few D6 (6-sided dice). Here’s how rolling works:

• Roll: 1d20 + Attribute Modifier vs Difficulty (10 easy, 15 normal, 18 hard)
• Boons: Roll 1d6 and add the highest result to your roll (stackable)
• Banes: Roll 1d6 and subtract the highest result from your roll (stackable)

Let’s get started!

AWSia: A Land of Cloud Wonders

Forged by the Ancient Amazonian Gods, AWSia is a mystical land where everything is powered by magical Clouds! Builders travel these lands in search of wonders and to build their best systems, harvesting the power of the Clouds.

But there’s a beast lurking in the shadows—one that, if not stopped, can make even the most experienced builders cry and bring our uptime down… the Latency Monster! Little does this beast know there’s a prophecy: a group of builders will rise to the challenge and find the hidden Lambda Scrolls, said to contain all the serverless secrets, powerful enough to defeat any latency. But who are these builders?

Meet our Builders… Elandra, Durik, and Grokka!

Each builder in AWSia embodies core AWS services and concepts—their abilities and strengths mirror the different areas and services they represent. Let me introduce you to our heroes…

Elandra the Mage Developer Cloud Elf

Coming from one of the most ancient ancestries of AWSia, Cloud Elves are said to have laid the first pillars of the land itself. They’re the keepers of foundational knowledge, maintaining order and best practices across the realm through their deep understanding of cloud architecture. Elandra wants to follow in those footsteps, traveling the lands not just to build new systems, but to fix any bug or architectural flaw she encounters. With her mastery of development magic and keen eye for optimization, she’s become the team’s go-to problem solver. But she knows she can’t do it alone.

Durik the Solutions Architect Data Dwarf

Data Dwarfs usually work in very close-knit communities, mining all the data they can get and maintaining the critical data flows across AWSia. They are resilient people but notoriously stubborn, especially when it comes to data integrity! Durik is a special case—he wasn’t content just observing and monitoring data flows (though he’ll happily do that any day if you ask him). So he decided to venture out and see what kind of systems he could build in the world, becoming a Solutions Architect and learning from every challenge he encounters alongside Elandra and…

Grokka the DevOps Ranger Container Orc

Grokka comes from a lineage of Container Orcs, a tribe famous across AWSia for their exceptional prowess in deploying and orchestrating workloads. Raised on the road, she learned young how to package magic into portable “containers” and launch them wherever needed. Container Orcs value agility and collaboration, bridging gaps between mages, data dwarfs, and all other builders. As a natural Ranger, Grokka stays one step ahead of trouble, automating everything she can and keeping the team’s systems flowing smoothly—and if there isn’t a script for a problem, she’ll write one on the fly.

I won’t get into detail on what each stat and ancestry do for now, but for a quick reference, each stat represents a core capability that every builder needs:

• Strength (Build)

  • Infrastructure Power — Build and maintain robust systems.

• Agility (Elasticity)

  • Scalability — Adapt quickly to demand changes.

• Intellect (Innovation)

  • Creativity & Code — Invent, automate, and develop solutions.

• Willpower (Resilience)

  • Disaster Recovery — Survive attacks or outages.

• Perception (Troubleshooting)

  • Monitoring & Diagnostics — Spot and fix issues early.

And so our Builders embark on their epic journey to find the legendary Lambda Scrolls!

A Monolith in Ruins…

After several days on their quest, our Builders stumble upon an ancient stone monolith towering over the landscape. At first awe-inspiring, it quickly becomes clear the structure is dangerously unstable—cracks spiderweb across its surface, and it looks like it might collapse at any moment.

“I can patch it up for now,” Durik muses, carefully examining the monolith, “but honestly, it’s just a matter of time before it crumbles again. With the Latency Monster always nearby, a temporary fix won’t last…”

Grokka steps forward, eyeing the looming edifice critically. “Elandra, think you could use that developer magic of yours to break this thing into smaller, more manageable pieces? This monolith is overloaded. If we split it up into lots of little services, they’ll be easier to handle and more resilient in the long run. Don’t worry, I’ve got your back if anything goes sideways!”

Elandra nods, rolling up her sleeves as a magical aura begins to gather around her fingertips. Grokka unslings her runed automation bow, standing ready to assist if anything goes awry. With Durik preparing to reinforce the structure if needed, the team gets set—Elandra focusing on her spell to decompose the monolith, Grokka at her side with scripts and tools at the ready.

But before she casts, let’s pause and talk about why our Builders made this choice…

Teaching Moment!

Let’s use this opportunity to learn a bit more about Monolith applications versus Microservices and why our Builders decided to break it apart instead of just fixing it.

When deciding how to build (or rebuild!) an application, you’ll hear a lot about Monoliths versus Microservices. Each approach has its strengths and weaknesses, and our brave Builders’ choice to move away from a crumbling Monolith is a perfect opportunity to explain why!

🗿 Monolith Applications

• What are they?
  A monolith is a single, unified application where all features, business logic, and dependencies are bundled together and deployed as one big block.

• Pros:

  • Simpler to start
  • Easier local development (at first)
  • Fewer moving parts in early stages

• Cons:

  • Hard to scale specific parts (if one part is slow, you have to scale the whole thing)
  • Changes in one area can accidentally impact everything else
  • Longer deployment times
  • The Latency Beast lurks within! Internal communication can get bogged down as the monolith grows, making performance unpredictable.

• AWS Examples:

  • Amazon EC2 (virtual machines to run large single applications)
  • Elastic Beanstalk (easier app deployment, but often for monolithic codebases)

🧩 Microservices

• What are they?
  Microservices break the app into smaller, independent components—each handling a specific job, communicating over APIs or events.

• Pros:

  • Each service can scale independently (banish the Latency Beast in bottlenecks)
  • Teams can develop and deploy features separately
  • Easier to adopt new technologies in part of your system
  • Failures are more isolated (a crash in one microservice doesn’t take them all down)

• Cons:

  • More complex architecture
  • Requires careful planning for communication and monitoring
  • You may face increased external latency between services (but you can architect for this!)

• AWS Examples:

  • AWS Lambda (serverless, run code for individual microservices)
  • Amazon ECS & EKS (deploy containerized microservices)
  • Amazon API Gateway (manage external/internal APIs between microservices)
  • AWS Step Functions (orchestrate multiple Lambda/microservice workflows)
  • Amazon SQS & SNS (event-driven communication between services)

👹 What About the Latency Beast?

• In a monolith, the Latency Beast sneaks in as the codebase grows—slow database calls and tangled function calls weigh the whole system down. Fixing these slowdowns is tough because everything is tightly coupled.
• In a microservices world, you can spot where the Latency Beast lives and scale/harden just that monster’s lair (add caching, scale compute, introduce async processing, etc.).
• BUT: microservices do add some overhead—network calls are slower than in-process calls. That’s why choosing the right AWS services (like using ElastiCache for caching, or API Gateway for low-latency routing) and good design is key.

Let’s Roll Some Dice!

Elandra prepares to cast the function (spell) “Hello Lambda”. Since it’s a big task, this will be a normal “difficulty class” (DC), meaning she’ll have to roll a 15 or higher on her d20 die! But no worries—since she’s a Mage Dev, she has a special class ability for this case:

• Function Cast:
  • When you cast a function spell, gain a boon on the roll

So let’s roll both 1 D20 and 1 D6!

We got an 11 + 2 + 1 from Elandra’s “Innovation” stat (because she’s casting a function), for a total of 14…so close! But Grokka notices that Elandra is about to fail, so she performs:

• Silent Deploy:
  • Gain 1 boon when rolling to fix something before it’s noticed.

So Elandra gets one boon die to add to her roll!

We got a 3, bringing the total to 17!

Our Builders broke up the Monolith to make the system more flexible, resilient, and ready to grow. With the right AWSia magic to back them up, they can defeat the Latency Beast and push forward on their quest for the Lambda Scrolls!

The Network Tunnels

After a well-earned rest, our Builders venture on to find the legendary Lambda Scrolls.

The path leads our heroes deep beneath the AWSia landscape, into the Arcane Network Tunnels—an intricate web connecting every region, database vault, and cloud fortress in the land. Dim magical data streams pulse along the walls, guiding their way.

Suddenly, a chilling roar echoes across the tunnels as the Latency Beast re-emerges, flanked by a swarm of Error Imps! In an instant, the data streams slow to a crawl. Bits drip sluggishly forward, every request and response bogged down by the creature’s corrupting aura. The tunnels overflow with snared packets and bottlenecked requests—the whole network is flooded with latency.

Elandra narrows her eyes. “If we push through, we risk getting trapped in a timeout stream!” she warns.

Chaos ripples through the tunnels as the Latency Beast and its Error Imps block the way forward. Grokka grits her teeth, readying her tools for a brute-force attack, but Durik pulls the group back for a moment.

“Wait,” Durik rumbles, peering through the clouds of lag. “If we barge in now, those imps will bury us in errors and retries. But I could draw their attention—create a diversion, make them think we’re coming straight through the main tunnel.”

Elandra’s eyes light up, catching on to Durik’s plan. “And create another route!” Grokka grins, already prepping her gear for some network sleight-of-hand. As Durik boldly steps forward, clanking his Data Dwarf tools and throwing out decoy packets, the Error Imps’ chaos zeroes in on him, clogging the main route even more.

Meanwhile, under cover of the ruckus, Elandra and Grokka work fast:

• Elandra raises her API Gateway Staff, weaving a secure, disguised endpoint that quietly branches off from the main tunnel.
• Grokka executes Latency Leap. Since they’re in a rush, it will help Elandra cast her spell more quickly.

Teaching Moment!

⚔️ Facing the Latency Beast Head-On

When our heroes take on latency directly, it’s all about preparation and teamwork:

• Auto Scaling summons extra compute (EC2 ASGs or Lambda concurrency) to handle a flood of traffic, so the tunnels never back up.
• Application Load Balancers (ALBs) spread the traffic evenly, clearing bottlenecks and letting every request find its way through.
• Monitoring and Logging with CloudWatch can be used just like Grokka uses her “Log Snoop” ability to spot trouble early, set alarms, and zero in on the hotspots slowing things down.
• When you fight head-on, you fix the problem at the source and learn a lot about what lurks in your tunnel. But it can take more resources, be time-consuming, and you’ll need sharp tools to respond in real time.

🪄 Rerouting with API Gateway & Serverless

But sometimes a clever builder avoids the battle altogether. If the main route is blocked, you can:

• Instantly shift traffic around trouble, always keeping requests flowing along the fastest path.
• Use API Gateway to quietly open up new endpoints, sidestepping bottlenecks with ease.
• Let Lambda’s scaling magic kick in automatically to soak up surprise spikes in traffic—no need to tinker with servers.
• Lean on event-driven spells (like EventBridge or SQS) to keep messages moving strong, no matter how wild things get.

Just like in AWSia, you’re never out of options: if the path is blocked, reroute and keep moving!

You get resilience and velocity by default: your system stays up and responsive while you quietly fix the root issue behind the scenes. And sure—rerouting doesn’t directly solve the underlying problem—but it buys you precious time, keeps customers happy, and gives you breathing room to investigate without downtime. It’s an essential tool in any legendary builder’s kit!

Dice Time!

Durik will be fighting to gain time while Elandra and Grokka prepare the new route. Let’s focus on Elandra and Grokka (I’m still testing fighting rules!).

This time it will be a DC of 18 since they’re in a rush. But since Grokka used Latency Leap, the DC goes down to 16.

With that said, Elandra raises her staff and says her enchanted words to cast API Link:

• API Link:
  • Create a temporary connection between two far-off services or places.

And we got a 17, bringing us to a total of 18!

With Durik’s decoys distracting the imps and the Beast, Grokka and Elandra finish linking up their hidden channel. Durik flashes the others a thumbs-up before slipping back to join them.

Together, the builders quietly shift their dataflow to the alternate route—with the Latency Beast and its minions still tangled in the cluttered main path, none the wiser.

In the cloud—and in AWSia!—you can often combine both approaches. Sometimes you need to scale up and monitor closely to fight latency head-on. Other times, you can use flexible cloud services like API Gateway and Lambda to route around trouble and keep customers (and heroes) happy. Knowing which to use, and when, is what makes a legendary builder.

The heroes emerge from the other side of the tunnels, data flowing as smoothly and quickly as ever—one step closer to the legendary Lambda Scrolls!

The Trial of the Lambda Scrolls

At last, the builders reach the hidden chamber deep beneath AWSia. Before them stands an immense, rune-carved gate—its stone surface pulsing softly with arcane energy. As they approach, the gate’s eyes flicker open and a booming voice echoes through the chamber:

“Only those who truly grasp event-driven power may take hold of the Lambda Scrolls! Solve my riddle and prove your worth, or be turned away.”

Durik looks to Elandra and Grokka with a grin. “Looks like it’s quiz time, friends.”

The gate’s glowing glyphs arrange themselves into a shimmering riddle for the party to answer…

Teaching Moment: The Power of AWS Lambda

As the gate swings open, the Lambda Scrolls glow brighter, revealing their secret: Lambda doesn’t care how it’s invoked—it responds to any event you configure.

This is what makes Lambda so powerful. Whether it’s:

• A scheduled cron job running reports every hour
• An HTTP request from your web app hitting an API
• A file upload to an S3 bucket triggering data processing

Lambda handles them all the same way: it executes your code, scales automatically, and you only pay for the milliseconds it runs.

This is event-driven architecture—your code sits dormant until something happens, then springs into action instantly. No servers to maintain, no resources wasted while idle.

In practice: One Lambda function can serve your API, process uploaded files, AND run scheduled tasks—all without you managing a single server.

The Journey’s End… or Just the Beginning?

With the Lambda Scrolls finally in hand, our heroes emerge from the ancient chamber. The scrolls’ wisdom flows through them—a profound understanding of event-driven architecture, serverless magic, and the true power of the Cloud.

As they step back into the light of AWSia, the Latency Monster’s roar grows distant. Armed with their newfound knowledge, Elandra, Durik, and Grokka know they can face any challenge the Cloud throws their way. The scrolls didn’t just give them power—they revealed a completely new way of building systems in AWSia.

Durik chuckles, rolling up the scrolls carefully. “Who knew the answer wasn’t fighting harder, but building smarter?”

Elandra nods, already thinking of the next system she’ll architect. “Serverless, scalable, resilient… this changes everything.”

Grokka grins, slinging her automation bow over her shoulder. “And no servers to babysit. My kind of magic.”

The three builders set off toward the horizon, ready for whatever adventures await them in the ever-expanding lands of AWSia. And somewhere in the distance, other builders are just beginning their own quests…you!

The Lambda Scrolls — Adventure Recap

Act 1 — The Crumbling Monolith

The Challenge: A massive stone monolith, unstable and ready to collapse
The Lesson: Monoliths are rigid and hard to scale. Breaking them into microservices creates flexibility and resilience.
AWS Connection: Moving from monolithic EC2 deployments to containerized microservices (ECS/EKS) or serverless functions (Lambda)

Act 2 — The Network Tunnels

The Challenge: The Latency Monster blocks the main path with its army of Error Imps
The Lesson: When faced with bottlenecks, you can fight head-on with scaling and monitoring, or route around the problem with smart architecture.
AWS Connection: Auto Scaling Groups, Application Load Balancers, API Gateway, and Lambda work together to maintain performance under pressure

Act 3 — The Trial of the Lambda Scrolls

The Challenge: Prove understanding of event-driven architecture to claim the scrolls
The Lesson: Lambda responds to any event—HTTP requests, scheduled jobs, file uploads, and more. One function, infinite possibilities.
AWS Connection: Event-driven architecture with Lambda at the center, triggered by EventBridge, API Gateway, S3, and dozens of other services

Final Takeaway

Serverless architecture unlocks agility, resilience, and scalability—without managing servers.

By embracing event-driven design and breaking away from monolithic thinking, builders can create systems that scale automatically, respond instantly to events, and only consume resources when actually needed. The Latency Monster doesn’t stand a chance against smart, serverless architecture.

Want to run your own AWSia adventure? Stay tuned for the full rulebook in a future post, where I’ll show you how to create your own builders and craft teaching moments for your team and friends!

Do you have any feedback? Don’t hesitate to contact me!