
Weekend Showcase Challenge: RescueOps AI
RescueOps AI is an autonomous disaster-response simulation that uses Amazon Bedrock to generate evolving emergency scenarios, create visuals, evaluate decisions, and adapt future challenges based on community performance. Built with AWS serverless services, it demonstrates how generative AI can turn preparedness training into an interactive, continuously evolving experience.
What if an AI system could create a new emergency-response challenge every day, evaluate how people respond, learn from their decisions, and continuously adapt the next scenario?
That is the idea behind RescueOps AI. It is an AI-powered emergency-response simulation platform designed to turn disaster preparedness into an interactive, continuously evolving experience.
****
Deployed Application
Live RescueOps AI application:
****
The application will provide the interactive scenario experience, AI evaluation, and leaderboard.
****
Source code:
The repository contains the AWS SAM infrastructure, Lambda functions, frontend, prompts, and supporting project files.
****
RescueOps AI combines Amazon Bedrock, AWS Lambda, Amazon EventBridge, Amazon DynamoDB, Amazon S3, Amazon API Gateway, and AWS IAM into a serverless architecture where AI doesn't simply answer questions, it creates the challenge, evaluates the response, and helps shape what comes next.
Every day brings a new crisis. Your decisions determine the outcome.
Vision & What It Does
Emergency situations are unpredictable. Decisions often need to be made quickly while multiple priorities compete for limited resources.
RescueOps AI explores how generative AI can make emergency-response training more engaging and dynamic.
Instead of presenting users with a fixed collection of predefined scenarios, RescueOps AI is designed around an autonomous daily scenario-generation loop.
Each scenario presents a fictional emergency situation such as flooding, infrastructure failure, severe weather, transportation disruption, or another large-scale incident.
The user receives a situation briefing and a visual representation of the incident, then makes a series of critical decisions.
For example:
A severe storm has flooded Riverside District.
A hospital is experiencing a power failure. Several roads are blocked. Residents in low-lying areas require evacuation, while emergency teams have limited resources.
The user must decide:
· Where should the first emergency team be deployed?
· Which infrastructure should receive priority?
· Which population should be evacuated first?
· How should limited emergency resources be allocated?
After submitting the response, Amazon Bedrock evaluates the decisions against the scenario's objectives and produces an AI-generated assessment.
The user receives a score, feedback on the decisions that were effective, and an explanation of what could have been done differently.
The system can then record the result and use aggregated community performance to influence the difficulty of future scenarios.
This creates a feedback loop:
Generate → Respond → Evaluate → Learn → Generate Again
The goal is not to replace professional emergency-management systems. RescueOps AI is a simulation and learning experience designed to demonstrate how generative AI and autonomous cloud workflows can be applied to preparedness and decision-making.
The Autonomous AI Loop
The most important part of RescueOps AI is that the system does not depend entirely on a user pressing a button to create new content.
Amazon EventBridge schedules the scenario-generation process.
When the scheduled event fires, AWS Lambda acts as the autonomous scenario-generation engine.
The Lambda function examines historical performance stored in Amazon DynamoDB and uses that information as context for generating the next scenario.
Amazon Bedrock Nova Pro then generates the scenario's narrative, decision points, possible responses, evaluation criteria, and difficulty.
Amazon Bedrock Nova Canvas generates a visual representation of the incident.
The resulting scenario and metadata are stored in DynamoDB, while generated images are stored in Amazon S3.
The new scenario is then ready for the next responder.
This gives RescueOps AI an important characteristic:
It can create fresh experiences without requiring a human administrator to manually author every scenario.
Multimodal AI with Amazon Bedrock
One of the aspects I wanted to explore was the combination of text and visual generation.
Amazon Bedrock Nova Pro is used for the reasoning and text-generation side of the system.
It can generate:
· Emergency scenarios
· Situation briefings
· Decision questions
· Response options
· Evaluation criteria
· Difficulty guidance
· Post-response feedback
Amazon Bedrock Nova Canvas adds the visual layer.
Instead of presenting users with only a block of generated text, each scenario can have a visual environment representing the incident.
This makes the simulation more immersive while demonstrating a multimodal generative-AI workflow.
****
How I Built It
I chose a serverless architecture because RescueOps AI does not need infrastructure running continuously.
The system is event-driven.
The autonomous generation process follows this flow:
Amazon EventBridge → AWS Lambda → Amazon Bedrock → Amazon S3 / Amazon DynamoDB
The user-facing workflow follows a separate path:
User → Amazon S3 frontend → Amazon API Gateway → AWS Lambda → DynamoDB / Amazon Bedrock
This separation keeps scenario generation independent from normal user traffic.
The daily generator performs the more expensive AI generation work when needed.
The user-facing Lambda functions primarily retrieve scenarios, process responses, evaluate submissions, and retrieve leaderboard information.
This means the application can remain lightweight while the autonomous generation engine operates independently.
****
Architecture Overview
The architecture is built around the following AWS services:
****
Amazon EventBridge
EventBridge provides the autonomous scheduling layer.
A scheduled rule invokes the scenario-generation Lambda so that RescueOps AI can periodically create a new emergency scenario without requiring manual intervention.
****
AWS Lambda
Lambda provides the serverless compute layer.
The application is separated into four functions:
· GenerateScenarioFunction — creates the next scenario
· GetScenarioFunction — retrieves the active scenario
· SubmitResponseFunction — processes and evaluates user responses
· GetLeaderboardFunction — retrieves ranking information
****
Amazon Bedrock — Nova Pro
Nova Pro provides the core generative-AI capabilities for scenario creation and response evaluation.
****
Amazon Bedrock — Nova Canvas
Nova Canvas generates the visual representation of the emergency scenario.
****
Amazon DynamoDB
DynamoDB provides persistent application state.
The architecture uses separate tables for:
· Scenarios
· Responses
· Leaderboard data
****
Amazon S3
S3 stores generated scenario images and provides the static hosting layer for the frontend assets.
****
Amazon API Gateway
API Gateway exposes the application's REST endpoints to the frontend.
The primary API operations are:
· GET /scenario
· POST /response
· GET /leaderboard
****
AWS IAM
IAM controls the permissions required by the Lambda functions to access DynamoDB, S3, and Amazon Bedrock.
The goal is to keep each component limited to the resources it actually needs.
****
The Complete Flow
The complete system can be summarized as follows:
1. Daily Trigger
Amazon EventBridge invokes the scenario-generation Lambda.
2. Analyze Previous Performance
The Lambda reads relevant performance information from DynamoDB.
3. Generate Scenario
Amazon Bedrock Nova Pro generates a new emergency scenario based on the desired difficulty and previous performance.
4. Generate Visual
Nova Canvas generates an image representing the scenario.
5. Store Scenario
Scenario information is stored in DynamoDB and the generated image is stored in Amazon S3.
6. User Interaction
A user opens RescueOps AI and retrieves the current scenario through API Gateway.
7. Submit Decisions
The user's decisions are sent to the response endpoint.
8. AI Evaluation
Amazon Bedrock evaluates the response and generates a score and explanation.
9. Record Performance
The response and score are stored for future analysis.
10. Adapt
Aggregated performance becomes an input into future scenario generation.
The result is an evolving simulation rather than a static collection of questions.
****
Adaptive Difficulty
A major design goal is to make RescueOps AI responsive to its community.
If users consistently achieve very high scores, future scenarios can become more complex.
If performance drops significantly, the system can reduce complexity.
The basic feedback loop is:
****
High performance → Increase challenge
Balanced performance → Maintain difficulty
Low performance → Reduce challenge
This does not require a complicated machine-learning pipeline.
Instead, the system demonstrates an important AI-agent principle: feedback from previous actions can influence future autonomous behavior.
****
Key Engineering Decisions
I deliberately chose a serverless AWS architecture.
There is no continuously running application server.
There is no database server to maintain.
There is no dedicated machine waiting for the next daily scenario.
Instead, AWS services are invoked when work needs to happen.
This approach makes the architecture simpler, scalable, and appropriate for a weekend build.
AWS SAM is used to define the infrastructure as code, allowing the complete backend architecture to be deployed consistently rather than manually creating each resource.
Another important decision was separating generation from serving.
Generating an AI scenario and serving a scenario to a user are fundamentally different workloads.
The generator can perform its work periodically, while the user-facing APIs can remain lightweight and focused on retrieving and processing application data.
****
Challenges
One of the biggest challenges in building an AI-generated simulation is consistency.
A generative model needs to produce scenarios that are understandable, coherent, and evaluable.
A scenario cannot simply sound interesting, its decisions need to have meaningful evaluation criteria.
This makes structured generation particularly important.
The AI output needs to contain predictable fields for the scenario, questions, choices, scoring information, and evaluation logic.
Another challenge is balancing visual generation with usefulness.
The generated image should reinforce the scenario rather than simply provide decorative artwork.
The architecture therefore treats the scenario description and visual-generation instructions as connected parts of the same generation process.
Finally, the application needs to remain small enough to build and deploy within a weekend.
That led to the decision to avoid unnecessary infrastructure and focus on a small number of AWS services with clearly defined responsibilities.
What I Learned Across the Summer Build
The AWS Summer Build Series has been a progression from experimenting with individual AWS services to thinking about complete cloud-native systems.
One of the biggest lessons has been understanding the difference between an application that simply responds to a user and an autonomous system that can perform work on its own.
EventBridge and Lambda make that distinction particularly powerful.
A scheduled event can wake up an otherwise idle system, perform meaningful AI-driven work, persist the result, and then disappear again.
I also learned how generative AI becomes significantly more interesting when it is connected to application state.
Generating a piece of text is useful.
Generating something, measuring how users interact with it, and using those results to influence the next generation cycle is much more powerful.
The Summer Build Series also reinforced the importance of choosing architecture based on the problem rather than adding technology for its own sake.
RescueOps AI intentionally uses a compact serverless architecture where each AWS service has a clear purpose.
What's Next
RescueOps AI is intentionally designed as a foundation that can evolve.
Future versions could introduce richer scenario categories, more sophisticated scoring, team-based simulations, historical performance analytics, additional emergency-resource constraints, and more advanced adaptive behavior.
However, the core concept remains simple:
Create a crisis.
Let people respond.
Learn from their decisions.
Create a better challenge tomorrow.
That is the experiment behind RescueOps AI, exploring how autonomous, multimodal generative AI can transform a static training exercise into a continuously evolving simulation.
Final Thoughts
RescueOps AI started with a simple question:
What happens when an AI doesn't just generate the simulation, but also learns from the people who use it?
The answer is a small step toward a different kind of application, one that can generate, evaluate, adapt, and continue operating without a human author creating every new experience.
Built with AWS serverless services and Amazon Bedrock, RescueOps AI brings together autonomous workflows, multimodal generative AI, persistent state, and interactive decision-making in one compact system.
****
One crisis. One response. One lesson. Every day, something new.
#AWS #AWSCommunity #AWSBuilder #AWSWeekendChallenge #RescueOpsAI #AmazonBedrock #NovaPro #NovaCanvas #AWSLambda #AmazonDynamoDB #AmazonS3 #AmazonEventBridge #APIGateway #Serverless #GenerativeAI #AI #DisasterPreparedness #AIForGood #CloudComputing #application
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article