AWS Builder Center
Rethinking How Communities Operate When Leaders Become Manual Operations Managers

Rethinking How Communities Operate When Leaders Become Manual Operations Managers

Running a community is about people, but much of the work behind it is coordination, speakers, volunteers, attendees, teams, deadlines, approvals, and last-minute changes. CommunityOps explores a missing operational layer: an AI-powered system that coordinates repetitive work across community operations while keeping humans in control of important decisions.

AWS Community Builder | AWS Cloud Club Captain 24' | Intern at Persistent Systems
The idea behind CommunityOps grew from our own experience building communities. As former AWS Cloud Club Captains, Soham Deshmukh and I (Bhoomi) have experienced firsthand the coordination that happens behind successful community events and the repetitive operational work that often falls on community leaders.



The Problem Behind the Community

Community leaders are meant to build communities.Somewhere along the way, many of them end up managing operations instead.

A speaker needs confirmation. A volunteer needs help. An attendee cannot find a ticket. A session suddenly needs to move. An approval is waiting. Someone has to connect all these moving pieces, and often, that someone is the community leader.The individual tasks are simple.
The coordination is not.
This became familiar through firsthand experience with community operations. As a Cloud Club Captain, I had seen what happens behind the scenes when people are trying to build meaningful communities while also coordinating speakers, volunteers, attendees, teams, deadlines, and last-minute changes.
At a broader level, community management teams coordinating multiple clubs and programs face the same challenge at a much larger scale: repetitive follow-ups, scattered information, changing requirements, multiple teams, and countless small tasks that still need someone to keep them moving.
Behind every community event is a layer of coordination that rarely gets seen.

That raised a bigger question:
If communities are growing, why does the operational layer still depend so heavily on manual coordination?
Existing event platforms already solve an important part of the problem. They manage registrations, tickets, agendas, attendees, and other event logistics.
But community operations require answering a different question:
“What needs my attention right now, and what can be handled without me?”
That gap became the starting point for CommunityOps: an AI Community Operations Teammate.
The idea was not to build another event-management platform.
It was to build a one-stop operational layer that could connect with the tools communities already use- event platforms, communication channels, workflows, and internal systems- and continuously coordinate the people and work required to make an event happen.
The broader ecosystem includes:
Over 160,000 student builders in over 600 communities spanning 63 countries
Over 900 Student Builder Campus Leaders and 590+ AWS User Groups.
These figures represent the ecosystem that inspired the problem and the scale at which this operational challenge can potentially exist—not current CommunityOps adoption.



The Product Decision Came Before the Technology

The first instinct with an AI project can be to ask:

“What can the model do?”
Community leaders do not necessarily need another dashboard. They need help connecting fragmented operational work.
So CommunityOps is designed around the operational areas that repeatedly consume attention:
SpeakerOps → TeamOps → AttendeeOps → IncidentOps → Check-In → Approvals → Audit
The goal is not to remove people from the process. It is to remove the repetitive coordination that keeps them away from the work that actually requires their judgment.
That meant thinking about CommunityOps as an operational system, rather than simply an AI interface.



Where Should AI Stop?

This became one of the most important product questions.

It is easy to imagine an Agent that receives a request, makes a decision, and executes an action.
But community operations involve real people, real records, permissions, and consequences.
Consider a simple question:
“Is this attendee eligible for check-in?”
An LLM should not guess.
The system needs to verify the actual registration, payment status, cancellation, refund status, and eligibility.
That led to a fundamental design principle:
Deterministic systems establish facts.
AI works with those facts.
Policies control authority.
Humans handle important decisions.
The Agent can understand a request, retrieve context, select an appropriate tool, prepare an action, and keep a workflow moving.
But it cannot silently perform an important action simply because the model suggested it.
As one question kept coming up during development:
“Can the Agent just do it?”
The answer became:
Only when it is authorized to do so. Otherwise, prepare it and wait.
That boundary matters because AI should create leverage, not remove accountability.
Sometimes the correct response from an intelligent system is also:
“I don't know yet.”
In an operational system, an honest unknown is safer than a confident wrong answer.



When Reality Doesn't Follow the Workflow

Community events have a habit of introducing their own test cases.
A speaker cancels
A room becomes unavailable.
An attendee loses their ticket.
A payment cannot be confirmed.
A volunteer needs help at the last minute.
These are not unusual edge cases. They are exactly where an operational system has to prove its value.
CommunityOps therefore behaves differently depending on what the system actually knows.
The flow is intentionally deterministic:
Search → Verify → Recover → Reconcile → Complete
The backend verifies the actual attendee and event state. If a ticket is missing, the system can recover it through a private PDF stored in Amazon S3 with a signed QR payload. The QR code is verified server-side, and recovery and completion are designed to be idempotent.
The Agent coordinates around this process, but it does not become the source of truth for registration, payment, or eligibility.
AI coordinates the work. Deterministic systems establish the facts.



That Boundary Shaped the Architecture

Once the product boundary was clear, the architecture became easier to reason about.

The Agent does not directly access the database. Instead, it works through typed tools with clearly defined inputs and outputs, validation rules, organization scope, policy information, and approval requirements.
CommunityOps architecture: connecting the AI Agent with deterministic services, workflows, authorization, and human approvals.

The operational loop follows:
Detect → Understand → Retrieve Context → Plan → Check Policy → Act When Authorized → Wait for Approval → Verify → Audit → Re-evaluate
This is what turns CommunityOps from an AI chatbot into an operational system.
The architecture was designed around these boundaries rather than around the AI model itself. The frontend provides the operational interface, while AWS services handle authentication, APIs, data, private storage, event-driven workflows, AI capabilities, and human approvals. Amazon Bedrock and Nova Pro power the Agent layer, while Lambda, DynamoDB, Step Functions, EventBridge, Cognito, S3, API Gateway, and CloudFront form the surrounding operational infrastructure.
The result is an architecture where AI can reason and coordinate within clearly defined boundaries, while deterministic services remain responsible for data, authorization, workflows, and execution.
The architecture above shows how these components come together.



The Interface Had One Job: Reduce Cognitive Load

A community leader already has enough things competing for attention.

So the Command Center was designed around a simple question:
“Does anything need me right now?”
Instead of presenting every possible piece of information, it focuses on operational health, attention items, the current brief, activity, and event state.
From there, leaders can move into the areas that require attention.
This also influenced how Agent actions are presented.
For higher-risk actions, the approval experience can show the proposed action, reason, evidence, affected resources, and risk information before a human makes the final decision.
The flow becomes:
Agent → Policy → Approval → Authorized Execution → Verification → Audit
The human is given a better loop.



IncidentOps: Because Events Rarely Follow the Plan

When a speaker cancels, a room changes, or a session needs to move, the problem is rarely just one task.
It becomes a chain of related actions. CommunityOps treats incidents as coordinated workflows rather than isolated messages.

AWS Step Functions helps manage multi-step processes where actions may depend on previous steps or human approval. This is where the difference between an AI assistant and an operational Agent becomes meaningful.
The system is not simply generating a response. It is helping coordinate a process.



Auditability Is Part of the Product

Operational automation creates another important question:
“What happened?”
For meaningful actions, CommunityOps maintains an auditable trail around:
Actor → Action → Result → Resource → Timestamp
Auditability was therefore treated as part of the product, not something to add later.
The same thinking applies to security.
CommunityOps uses Cognito authentication and organization-scoped authorization. Backend checks remain authoritative, while DynamoDB data is scoped by organization. Private ticket objects use short-lived access, and QR payloads are verified server-side.
Tenant isolation was also tested directly.
A request attempting to cross organizational boundaries was expected to fail, and did so with a 403 response.
Because helping one organizer should never mean exposing another organization's data.



When Architecture Met Reality

Architecture diagrams rarely capture the whole development story.
During implementation, we encountered real constraints.
An API Gateway CORS configuration initially caused preflight requests to receive a 401 response because the  OPTIONS  route was passing through authentication. We separated preflight handling from authenticated application requests.
The Bedrock Agent also required changes when the initially planned model configuration was not available in the required deployment setup. The deployed Agent was moved to Amazon Nova Pro.
IAM permissions had to be narrowed. Deployment identity and permissions-boundary issues had to be resolved. CloudFormation secret handling needed attention.
These were not distractions from the product.
They were part of building the product.
A system can have a compelling interface and still fail if its authorization model is weak, its integrations are unreliable, or its deployment assumptions do not match reality.



Building With Kiro, Not Just With Kiro

Kiro became part of the development process across brainstorming, architecture exploration, implementation, debugging, test generation, refactoring, and validation.
Kiro was used as a development partner, not as an autonomous builder making product decisions.
Steering helped preserve project identity, architecture boundaries, security requirements, naming conventions, and code practices. Hooks supported repeated validation and development reminders.
The experience reinforced a broader lesson:
Good Agent systems need good boundaries more than good prompts.
The quality of an AI product depends not only on what the model can do, but also on what the surrounding system deliberately prevents it from doing.



Proving the System, Not Just the Demo

A hackathon  demo  can make a system look complete in three minutes. Testing tells you whether it actually holds together.
CommunityOps reached:
565 passing tests across 59 files | 25/25 targeted Agent and Incident regression tests passing.
Live validation also covered deployment, API Gateway, Lambda, Cognito, tenant isolation, DynamoDB, private S3 storage, Check-In, QR verification, idempotent recovery, Bedrock Agent behavior, EventBridge, and Step Functions human-approval waits.


A simple way to think about CommunityOps is:
Hours saved per event × Events supported × Number of Organizers using CommunityOps
The next step is not simply making the Agent more capable.
It is making the system more useful where people actually work.



Explore CommunityOps

 CommunityOps  is built on AWS and developed with Kiro, to turn the invisible coordination behind community events into an intelligent, auditable, human-centered operational layer.



What We Learned

One lesson stood out: using Kiro blindly is not the goal. Understanding the architecture first, foundations, and problem first matters; without that context, AI can increase output but reduce productivity, optimization, and engineering judgment.


Stay Connected, Grow Together!
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article