AWS Builder Center
Building CivicFix on AWS: From Citizen Reports to Resolved Incidents

Building CivicFix on AWS: From Citizen Reports to Resolved Incidents

Civic complaints rarely exist as isolated events. In this build, I explored how a serverless AWS architecture can connect citizen reports, incident grouping, department workflows, image evidence, and resolution tracking into one end-to-end system.

A civic issue can be reported by one person and then reported again by several others on the same day.
For example, three different people might report the same pothole. The system could treat those as three separate complaints, even though there is really only one problem that needs to be fixed.
While building CivicFix, this made me think about a different approach:
What if reports were treated as evidence of an underlying civic incident instead of being treated as completely separate problems?
That became the main idea behind CivicFix.
CivicFix is a civic issue reporting and resolution platform that connects citizens with authorities through a single workflow:
Report → Understand → Cluster → Route → Resolve → Verify
The key distinction is:
REPORT ≠ INCIDENT
A report is what a citizen submits. An incident represents the underlying problem that an authority needs to act on.



The problem with traditional complaint flows

A basic complaint system can look like this:
Citizen
↓
Complaint
↓
Department
↓
Closed
This is useful for recording complaints, but it doesn't answer some important questions.
  • Are multiple complaints actually about the same issue?
  • Which department should handle it?
  • How should authorities prioritize it?
  • What evidence shows that the work was completed?
  • Has the citizen confirmed that the issue was actually fixed?
These questions shaped how I designed CivicFix. How I designed the workflow
The main workflow in CivicFix is:
Citizen Report
↓
Issue Structuring
↓
Duplicate Detection
↓
Incident
↓
Department Routing
↓
Authority Action
↓
Resolution Evidence
↓
Citizen Verification
The citizen starts with a report containing information such as the description, category, location and image evidence.
Instead of sending every report directly into an independent workflow, CivicFix uses the report information to determine whether it belongs to an existing incident.
This is where the distinction between a report and an incident becomes useful. Multiple reports can provide additional evidence for the same underlying issue while the authority can still manage one operational incident.



AWS architecture

I wanted the application to remain lightweight, so I used a serverless architecture rather than maintaining a traditional backend server.
CivicFix
│
React + Vite Frontend
│
AWS Amplify
│
API Gateway HTTP API
│
Lambda
/ \
/ \
DynamoDB S3
Issue Data Private Images
The main AWS services used are:
  • AWS Amplify — frontend hosting
  • Amazon API Gateway — HTTP API layer
  • AWS Lambda — backend operations
  • Amazon DynamoDB — issue and incident data
  • Amazon S3 — private image storage
  • IAM — service permissions
  • AWS SAM/CloudFormation — infrastructure definition
This architecture allowed me to deploy the application without managing servers.



Why I used Lambda and API Gateway

CivicFix has several independent backend operations, including creating reports, retrieving issues, updating their status and generating upload URLs.
These operations map naturally to Lambda functions behind API Gateway.
The flow for a typical API request is:
React Application
↓
API Gateway
↓
Lambda Function
↓
DynamoDB
↓
API Response
↓
React Application
Keeping these responsibilities separated also made debugging easier. When something failed, I could isolate whether the problem was in the frontend request, API route, Lambda logic or database operation.



Handling report images with private S3 storage

Images are useful evidence for civic issues, but I didn't want to make the S3 bucket publicly accessible.
CivicFix therefore uses presigned upload URLs.
The upload flow looks like:
Browser
↓
Request upload URL
↓
API Gateway
↓
Lambda
↓
Presigned S3 URL
↓
Browser uploads directly to S3
The image itself does not need to pass through the application server.
The S3 bucket remains private, while the presigned URL provides temporary controlled access for the upload operation.
This was also one of the areas where I encountered real integration issues during development, which made the separation between the frontend, Lambda and S3 especially useful when debugging.



Issue lifecycle

CivicFix doesn't treat an issue as simply open or closed.
The current workflow includes states such as:
REPORTED
↓
VERIFIED
↓
ASSIGNED
↓
IN_PROGRESS
↓
RESOLVED
↓
NEEDS_VERIFICATION
This allows the authority workflow to represent what is actually happening to an incident.
For example,  IN_PROGRESS  means that the authority has started working on the issue, while  RESOLVED  indicates that the authority has marked the work as completed.
The citizen verification step provides another layer after that.



What I learned while building it

One of the biggest lessons from this project was that connecting cloud services is only part of building a serverless application.
The boundaries between services matter.
A seemingly simple image upload can involve:
Frontend
↓
API Gateway
↓
Lambda
↓
S3
Similarly, separating reports from incidents makes the data model more useful, but it also means the frontend and backend need to understand the relationship between those two entities.
I also learned that debugging a serverless application often means following a request through several services instead of looking at one component in isolation.
That experience changed how I approached the final integration and deployment of CivicFix.



Deployment

The React/Vite frontend is deployed using AWS Amplify.
The backend infrastructure is defined using AWS SAM/CloudFormation, which makes the AWS resources and configuration reproducible.
The deployed architecture is:
React/Vite
↓
AWS Amplify
↓
API Gateway
↓
Lambda
↓
DynamoDB
+
Private S3
The application is publicly deployed and the source code is available here:



Final thoughts

The main idea behind CivicFix is simple:
A citizen report should not necessarily become a separate work item.
Multiple reports can describe one underlying incident, and the system should help authorities move that incident toward an actual resolution.
The workflow becomes:
Report
↓
Understand
↓
Cluster
↓
Route
↓
Resolve
↓
Verify
Building CivicFix gave me practical experience with serverless application architecture, AWS service integration, private object storage, infrastructure definition, frontend/backend integration and production deployment.
More importantly, it changed how I think about civic applications: the goal shouldn't just be to collect complaints. The system should help connect those reports to the work required to resolve the underlying problem.
CivicFix — From Citizen Report to Resolved Incident.
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