
CommunityOps: Building a Human-Controlled AI Operations Agent for Community Events on AWS
CommunityOps is an AI-powered operations layer for community events that helps teams handle repetitive coordination while keeping people in control of important decisions.
CommunityOps: Building a Human-Controlled AI Operations Agent for Community Events on AWS
Community events often look simple from the outside.
There is an event page, a registration form, a few speakers, volunteers, attendees, and a schedule.
But as the event gets closer, the real work begins.
A speaker needs a follow-up. A volunteer is overloaded. An attendee cannot find a ticket. A payment needs to be checked. A session has an issue. A team member is waiting for a decision.
The problem is not that these tasks are difficult individually.
The problem is that many small operational tasks happen at the same time.
That is the problem we wanted to solve with CommunityOps.
CommunityOps is an AI-powered operations system for community events. It helps community leaders handle repetitive coordination work while keeping people in control of important decisions.
Let software handle repetitive coordination. Let humans stay in control of important decisions.
The Problem We Started With
Our idea came from the practical side of organizing community activities.
Teams regularly coordinate:
- Speakers
- Volunteers
- Attendees
- Registrations
- Payments
- Check-in
- Event tasks
- Incidents
- Follow-ups
- Approvals
Most event platforms focus mainly on registration and event information.
That leaves another important question:
What needs my attention right now?
An organizer may need to check multiple tools, messages, spreadsheets, and dashboards to answer it.
We wanted to build an operations layer that connects these activities instead of building another registration platform.
Meet CommunityOps
CommunityOps follows a simple operating loop:
Detect → Understand → Retrieve context → Plan → Check policy → Act when authorized → Wait for approval when required → Verify → Audit → Re-evaluate
The system separates four important responsibilities.
Deterministic Systems Establish Facts
Backend services and databases answer questions such as:
- Does this registration exist?
- Was the payment recorded?
- Is the attendee eligible?
- Has a ticket already been generated?
- What is the current incident state?
- What is the current budget total?
The AI does not guess these values.
AI Works With Those Facts
The Agent can:
- Understand a natural-language request
- Select the correct operational tool
- Summarize event status
- Prepare recommendations
- Draft communications
- Highlight possible operational issues
Policies Control Authority
The AI does not decide what it is allowed to do.
Authorization is handled by the backend and policy layer.
Workflows Handle Multi-Step Operations
AWS Step Functions coordinates workflows that involve multiple steps, including speaker follow-up and incident response.
Humans Handle Important Decisions
High-risk actions stop at a human approval boundary.
The result is a simple rule:
The Agent can prepare an important action, but it cannot silently perform it just because the model suggested it.
Why We Did Not Build Just Another Chatbot
A chatbot can generate a convincing answer.
That is not enough when the answer affects a real attendee, payment, registration, or event operation.
Imagine an organizer asks:
“Is this attendee paid and eligible for check-in?”
The Agent should not guess.
It should call the correct registration and payment tools, receive the real backend results, and then explain the result.
That is why CommunityOps uses a typed tool architecture.
Each tool has:
- A clear name
- Defined inputs
- Defined outputs
- Validation
- Organization scope
- Policy information
- Approval requirements where needed
- Audit information for important operations
The model does not directly access the database.
The flow is:
Agent
↓
Typed Tool
↓
Backend
↓
Real Data
↓
Tool Result
↓
AgentThis keeps the AI connected to a controlled set of backend operations.
Agent Architecture
CommunityOps organizes operational capabilities into focused areas.
Supervisor
|
+---------------+---------------+
| | |
v v v
Check-In Ops Speaker Ops Team Ops
| | |
+---------------+---------------+
|
v
Attendee Ops
|
v
Incident OpsExamples of typed tools include:
registration_lookup
payment_lookup
verify_registration
generate_ticket
complete_checkin
speaker_lookup
schedule_followup
task_create
task_update
dependency_check
attendee_lookup
missing_info_scan
incident_analyze
backup_search
session_rescheduleThe Agent uses these tools instead of directly accessing the underlying data stores.
The Agent Loop
Every request follows a controlled flow.
User Request / Event
|
v
Observe
|
v
Retrieve
|
v
Reason
|
v
Policy Check
|
+---+---+
| |
Low/Med High Risk
| |
v v
Execute Approval
| |
| Approve
| |
+---+---+
|
v
Verify
|
v
Audit
|
v
Re-evaluateThis design also gives CommunityOps a clear response when things go wrong.
Missing Information
The Agent explains what information is missing instead of inventing an answer.
Multiple Possible Matches
The Agent asks the human to select the correct record instead of guessing.
External Service Failure
The system does not report a false success.
Tool Failure
The failure is recorded so the operation can be retried or escalated.
Approval Timeout
The workflow can wait or escalate instead of silently continuing.
One important lesson from the project was:
In an operational system, an honest “I don't know yet” is better than a confident wrong answer.
Check-In: A Deterministic Event-Day Flow
Check-In is one of the most important parts of CommunityOps.
Imagine an attendee reaches the venue but cannot display their ticket.
The volunteer needs an answer quickly.
CommunityOps handles the process as:
Search → Verify → Recover → Reconcile → Complete
The backend checks the real records for:
- Registration
- Event
- Registration status
- Payment
- Cancellation
- Refund
- Eligibility
This is intentionally not an AI decision.
If the attendee cannot find a ticket, CommunityOps can recover it.
The recovered ticket is generated as a private PDF and stored in Amazon S3 with a signed QR payload.
The QR payload is verified server-side.
Recovery and completion are also designed to be idempotent.
That means repeating the same request should not accidentally create duplicate actions.
For example, clicking a completion action twice should not result in two check-ins.
When multiple possible attendees match a search, CommunityOps asks the human to select the correct person.
When payment cannot be confirmed, the system creates a recovery case instead of showing a false payment confirmation.
This is one of the most important design principles in the project:
Deterministic operations should stay deterministic.
Human-in-the-Loop Approval
The approval system is a core part of CommunityOps.
The flow is:
Agent → Policy → Approval → Authorized Execution → Verification → Audit
The interface clearly separates an action that is prepared from one that has actually been performed.
For high-risk actions, the Agent can prepare:
- The proposed action
- The reason
- Supporting evidence
- Affected resources
- Projections
- Risk information
A human must approve the action before execution.
CommunityOps also does not expose:
- Chain-of-thought
- Hidden reasoning
- System prompts
- Internal model details
- Token usage
- Internal policy implementation
The interface focuses on useful evidence, action details, status, and approval information.
Command Center
The first screen of CommunityOps is the Command Center.
Instead of making an organizer check multiple pages, the Command Center starts with one question:
Does anything need me right now?
It combines deterministic operational information for:
- Health
- Attention
- Current brief
- Activity
- Event state
From there, the organizer can move into:
SpeakerOps → TeamOps → AttendeeOps → IncidentOps → Check-In → Approvals → Budget → Agent → Audit
The goal is to turn separate operational tasks into one connected workflow.
IncidentOps
Events do not always go according to plan.
A speaker may cancel.
A room may become unavailable.
A session may need to be moved.
A team may need help.
CommunityOps includes IncidentOps for these situations.
It provides incident details, discussion, linked tasks, and dedicated actions for incident management.
AWS Step Functions is used for workflows that require multiple coordinated steps and a human approval point.
This gives the incident a visible state instead of making the process disappear into a chat conversation.
Audit Is Part of the Product
Important AI-assisted actions should not disappear into a chat window.
CommunityOps keeps an operational audit trail containing:
- Actor
- Action
- Result
- Resource
- Timestamp
This helps answer questions such as:
Who changed this?
What happened during the incident?
Was this action actually completed?
The audit view provides operational history without exposing hidden model reasoning.
For us, auditability is part of the product design, not an afterthought.
Security and Tenant Isolation
Security was part of the architecture from the beginning.
Amazon Cognito handles authentication.
The current role model includes:
LEADER
TEAM_MEMBEROrganization membership is also part of the authorization model.
The main DynamoDB partition boundary uses:
PK = organization_idOrganization context is carried through API operations, tool calls, and workflows.
The frontend cannot simply change an organization value and gain access to another organization's data.
Backend authorization remains authoritative.
We also tested cross-organization access with the restricted demo identity, and the request failed with 403.
Ticket objects are private and accessed using short-lived presigned URLs.
QR payloads use server-side HMAC verification.
Operational changes create audit events.
We also performed focused live checks of the Agent and Incident workflow policies and did not find unrestricted
Action: "*" or Resource: "*" permissions in those checked policies.No passwords, AWS keys, Cognito tokens, or demo credentials are stored in the frontend.
AWS Architecture
CommunityOps uses a serverless AWS architecture.
User
|
v
CloudFront + Private S3
|
+--> Amazon Cognito
|
v
API Gateway
|
v
AWS Lambda
|
+--> DynamoDB
|
+--> Private S3 Ticket Storage
|
+--> Amazon Bedrock + Nova Pro
|
+--> EventBridge
|
+--> Step Functions
|
+--> Policy Enforcement
|
+--> Audit TrailThe frontend is built with:
React 19 + TypeScript + Vite + React Router
The backend uses:
Python 3.12 + AWS Lambda + Pydantic + boto3
The main AWS services are:
Amazon Cognito : Handles authentication and role and organization context.
Amazon API Gateway : Provides the protected REST API.
AWS Lambda : Runs backend application logic without managing application servers.
Amazon DynamoDB : Stores event, team, attendee, incident, task, and operational state using organization-scoped keys.
Amazon S3 : Stores private ticket artifacts and frontend assets.
Amazon CloudFront : Delivers the React application through a private S3 origin.
Amazon Bedrock : Provides the model layer for the operations Agent.
Amazon Nova Pro : Powers the deployed Bedrock Converse tool-use flow.
AWS Step Functions : Coordinates multi-step workflows that can include human approval.
Amazon EventBridge : Provides the custom event bus for domain events.
AWS SAM and AWS CloudFormation : Define and deploy the AWS infrastructure in a repeatable way.
The deployed application runs in
ap-south-1 .Building on Real AWS Services
One of the biggest lessons from this project was that a deployment can succeed while part of the application is still broken.
We faced several real AWS integration problems.
- API Gateway CORS - Our first browser preflight requests were rejected with
401. The preflight request was going through authentication. We separated theOPTIONSpath from the default authorization flow and then tested the browser request again.
- Bedrock Model Compatibility - Our first model configuration was not usable in the target account. We also found differences around model availability and inference profiles. We checked the available AWS-native model option and moved the deployed Agent to Amazon Nova Pro. The typed tool architecture did not need to change.
- IAM Permissions - The Agent Lambda required permission for the model resource. We narrowed the permissions instead of using broad wildcards.
- Deployment Identity - AWS profile and permissions-boundary differences caused deployment problems. We learned to use one explicit deployment identity and verify the permissions attached to it.
- CloudFormation Secrets - We had to preserve
NoEchoparameters while updating the stack so that secret values continued to be handled correctly. These problems were important parts of the learning process.
Cloud development is not only about writing code. It is also about understanding identity, permissions, service behavior, and deployment state.
Testing What We Built
We did not want the demo to depend only on a happy browser path.
Our validation included:
- Frontend unit and integration tests
- Authorization tests
- Policy tests
- Agent regression tests
- Incident regression tests
- TypeScript checks
- Lint checks
- Production build checks
- Live AWS service checks
The final frontend validation produced:
565 passing tests across 59 files
We also had:
25/25 targeted Agent and Incident regressions passing
Live checks were performed against the deployed AWS infrastructure rather than relying only on mocks.
The verified live paths included:
- CloudFormation deployment
- API Gateway routing
- Lambda execution
- Cognito authentication
- Tenant isolation
- DynamoDB
- Private encrypted S3 ticket storage
- Check-In
- QR verification
- Idempotent recovery and completion
- Bedrock Agent conversation
- EventBridge ingestion
- Step Functions reaching the human-approval wait
What We Learned With Kiro
This project was our first end-to-end Kiro development experience.
We used Kiro for:
- Brainstorming
- Architecture exploration
- Implementation
- Debugging
- Test generation
- Refactoring
- Validation
- Deployment assistance
We did not treat Kiro as a system that should build the entire product without supervision.
We used it as a development partner while we continued to make the product and architecture decisions.
Steering helped us preserve important project rules such as:
- Product identity
- Naming
- Security boundaries
- Architecture rules
- Code conventions
Hooks helped with repeated validation and development reminders.
The biggest lesson was:
Good Agent systems need good boundaries more than good prompts.
A strong prompt cannot fix weak authorization.
A polished chatbot cannot replace deterministic payment verification.
An LLM should not become the source of truth for a registration record.
The system needs clear boundaries first.
What We Would Improve Next
The hackathon version is working, but there are still clear next steps.
We would like to:
- Add measured organizer-time analytics.
- Run more complete rehearsals using both leader and team-member identities.
- Connect reviewed EventBridge rules to workflow starts.
- Improve observability and operational alerts.
- Measure actual time saved during real community events.
- Improve onboarding and recovery based on real user feedback.
We deliberately do not claim production adoption or a global number of hours saved.
The metric we want to measure next is:
Hours saved per event × Events supported × Organizers using CommunityOps
This gives us a clear way to measure real impact after the hackathon.
Who Could Use CommunityOps?
CommunityOps is designed around distributed community-event operations.
Potential direct users include:
- Community leaders
- Event organizers
- Team leads
- Speaker coordinators
- Registration and check-in leads
Indirect users include:
- Attendees
- Speakers
- Volunteers
- Sponsors
- Venue teams
- Logistics teams
The AWS Student Builder Group footprint described in the hackathon brief spans 977+ universities across 63+ countries.
The project context also describes around 590 AWS User Groups.
These numbers describe the broader community ecosystem that inspired the problem.
They do not represent CommunityOps adoption.
The hackathon version is a working prototype. The next step is to learn what happens when organizers use it during real events.
Final Thoughts
We started CommunityOps with a simple observation:
The hardest part of running a community event is often not planning the event. It is coordinating everything happening around it.
That led us to build an operations system where AI can help with repetitive work while important authority remains with people.
AWS gave us the building blocks for the system:
- Amazon Cognito for identity
- Amazon API Gateway for APIs
- AWS Lambda for compute
- Amazon DynamoDB for operational data
- Amazon S3 for private ticket storage
- Amazon EventBridge for events
- AWS Step Functions for workflows
- Amazon Bedrock for AI
- Amazon Nova Pro for the deployed model path
- Amazon CloudFront for delivery
- AWS SAM and AWS CloudFormation for infrastructure
Kiro helped us move faster through architecture, implementation, debugging, testing, and validation.
But the biggest lesson was not about one AWS service or one AI model.
It was about where to place the boundaries.
CommunityOps helps community leaders spend less time coordinating repetitive operations while keeping people in control of important decisions.
Built with AWS. Built with Kiro. Built for community operations.
#BharatBuilds
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article