
From the Kitchen to the Dining Room: Shipping an AWS Security Quiz App with Amazon Quick Apps
I built a no-code AWS Security practice quiz app with Amazon Quick Apps and presented it at QuickQuest Week 8, my first time as a community speaker. This walks through the difference between a flow (the kitchen) and a shipped app (the dining room), connecting a Quick Space to ground questions in real exam content, and why the parts that didn't work on the first try mattered just as much as the parts that did.
Where it all began
On August 27, I presented a project I built using Amazon Quick Apps: a no-code AWS Security certification practice quiz app. This was my first time stepping up as a community speaker, for QuickQuest Week 8, and the session was originally planned face-to-face before I moved it online out of concern for participants given how overwhelming the weather was that week. Looking back, I think it was the better call for everyone involved.

The app itself is simple on the surface: a user opens a link, asks for a practice question, picks an answer, and gets told whether they're right along with a short explanation. But the process of getting there, and of explaining that process live to a room full of students and working professionals, taught me more about what "shipping" actually means than the finished app does on its own.
The problem with flows
Before this project, I had already built an AWS certification exam flow for myself. A flow works, but it lives entirely inside the editor: steps, @references, configuration screens, all of it built for someone who already knows how to navigate the tool. It's powerful, but it's mine. Nobody else can walk in and use it without me sitting next to them explaining what each node does.

That's the distinction I kept coming back to while presenting this project: a flow is the kitchen. It's where all the raw work happens, the ingredients, the recipe, the prep. But a kitchen isn't something you hand to a guest. You need a dining room, a space where someone can sit down, order, and get a result without ever seeing what happened behind the scenes.
Amazon Quick Apps is that dining room.
Building the shell
The first step was describing the app in plain language, not code. I typed a single prompt into the Apps landing page:
"Build an AWS Security certification practice quiz app. It should have a clean single screen where a user can request a practice question about AWS Security, see the question with multiple choice options, select their answer, and get told whether they are right or wrong with a brief explanation. Keep it simple: one question at a time, one screen."
Within seconds, the agent generated a working interface: a box, a button, a result. Clean, minimal, exactly what a stranger could open and understand without instructions.

But when I actually tested it, something was missing. The questions it generated were technically about AWS Security, but they were generic, pulled from the model's general training rather than from any specific exam content. The dining room looked ready to serve, but there was no kitchen behind it yet.
Connecting the engine
This is where the project's real lesson showed up for me. I had already built a Quick Space earlier, a place where Amazon Quick stores documents and grounds AI responses in your actual content instead of general knowledge. I uploaded an AWS Security mock exam file covering the five core domains: incident response, logging and monitoring, infrastructure security, identity and access management, and data protection.

Connecting that Space to the app was a matter of one more plain-language instruction in the chat panel, asking the agent to ground every quiz question in the Space's content instead of general knowledge.

Once authorized, the app created its own agent instance backed by that Space. Same interface, same box, same button, but now the source of the answers had completely changed. The kitchen was finally plugged in behind the dining room.
Where I struggled, and why that's fine
I won't pretend everything clicked into place smoothly. There were parts of this build, particularly around making sure the Space content integrated cleanly without producing unexpected or off-target responses, where I had to stop, re-read what I'd instructed the agent to do, and try again. It wasn't a straight line from prompt to polished app.

But that struggle is part of the point I wanted to make when I presented this. Building something and shipping it doesn't mean getting it right in one try. It means being willing to sit with the parts that don't work yet, adjust, and come back to it. A quiz app that only serves generic questions isn't a failure, it's a checkpoint. The gap between "it runs" and "it's grounded in something real" is where the actual building happens. Shipping isn't a single moment where you press generate and walk away. It's a process you keep returning to, refining piece by piece until the thing you handed someone actually holds up when they use it.
What this means beyond the quiz app
The bigger idea I wanted to leave people with is that no-code tools like Amazon Quick Apps don't remove the need to understand what you're building, they just change where that understanding shows up. You still have to know what "grounded" means versus "generic." You still have to test, notice the gap, and go fix it. The tool moves faster, but the judgment is still yours.

If you're thinking about trying this yourself: start with something you already understand well enough to notice when it's wrong. That's what let me catch the generic-question problem immediately instead of assuming the app was finished. And when you hit a part that doesn't work on the first pass, that's not the project failing. That's just what building looks like.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article