
Weekend Showcase Challenge: StreetPulse
StreetPulse turns everyday reports of potholes, flooding, garbage and damaged infrastructure into structured community signals and a living city pulse using AWS serverless services and Amazon Nova.
Cities are constantly telling us where something is wrong.
A flooded road slows down an entire neighborhood. A pothole becomes a daily problem for hundreds of drivers. A broken streetlight makes a familiar street feel different after dark. Garbage builds up in one place while another issue appears only a few blocks away.
The signals are already there. The problem is that they are scattered.
That was the idea behind StreetPulse.
I wanted to explore a simple question:
What if a city could tell us where it hurts?
StreetPulse is an AI-powered civic intelligence platform that turns everyday infrastructure reports into structured community signals and over time, a living picture of what a city needs most.
The idea eventually came down to one sentence that guided most of my design decisions:
One report is a complaint. Together, they become a pulse.
From a photo to a structured civic report
I wanted the reporting experience to be simple enough to make sense immediately.
A user opens StreetPulse, uploads a photo of an issue such as a pothole, flooding, garbage accumulation, road damage or another infrastructure problem, selects its location and optionally adds some context.
From there, AWS takes over.
The browser first requests a short-lived upload URL from the backend. The image is then uploaded directly to a private Amazon S3 bucket rather than passing large image files through the API.
Before upload, the frontend also attempts to resize large images and reduce their size. Apart from improving the user experience, this was an important part of keeping the project cost-conscious.
Once the image is stored, the report is sent through Amazon API Gateway to AWS Lambda.
Lambda retrieves the private image from Amazon S3 and sends it to Amazon Nova Lite through Amazon Bedrock.
Nova analyzes the infrastructure issue and returns structured information including:
- Category
- Subcategory
- Severity
- Priority
- A concise assessment
- Possible impacts
- Confidence
I deliberately did not allow the model to return arbitrary categories.
The backend validates the model output against controlled values, clamps confidence values, limits output lengths, and validates the result before anything is stored.
I wanted AI to help understand the report without allowing it to silently become the source of truth.
StreetPulse therefore describes severity as an AI assessment rather than an official government determination.
Making the map real
An early version of StreetPulse could show reports, but I realized quickly that a civic platform becomes much more meaningful when location is actually part of the data rather than just a label.
The current version uses Leaflet and OpenStreetMap for the interactive map.
Users can click directly on the map, move the marker, or explicitly press Use My Location to request browser geolocation.
StreetPulse stores the actual latitude and longitude with the report.
I chose not to add another paid mapping service simply to make the AWS architecture larger. OpenStreetMap was enough for the current use case, and I wanted every AWS service in the project to have a clear reason for being there.
One issue, many people
This became one of my favorite parts of the project.
Imagine five people report the same flooded intersection.
Treating those as five unrelated records would miss the most useful information in the data.
Those reports together are evidence that the issue matters.
StreetPulse therefore performs community signal clustering.
The current implementation intentionally uses deterministic logic rather than another AI call.
Two reports can become part of the same community signal when they:
- Belong to the same primary issue category
- Are within approximately 200 metres
- Were reported within a 72-hour window
The geographic distance is calculated using the Haversine formula.
When related reports are found, StreetPulse groups them under the same community signal and updates information such as:
- Signal count
- First reported time
- Latest report time
A single report can therefore become:
1 Community Signal
and later:
5 Community Signals
without calling an LLM to solve a problem that ordinary code can handle well.
That became one of the most important lessons from this build:
Use AI where it adds intelligence. Use normal software engineering where it does the job better.
Giving the city a memory
At this point StreetPulse could analyze reports, place them on a map, and identify repeated issues.
But something still felt missing.
If the project was really supposed to represent the pulse of a city, it needed to understand change over time.
That led to the Daily City Pulse.
Amazon EventBridge runs a scheduled workflow once per day.
It invokes a dedicated AWS Lambda function, which reads recent reports from Amazon DynamoDB and calculates statistics such as:
- Reports today
- Active community signals
- Critical signals
- Resolved reports
- Most reported issue
- Most affected area
- Emerging hotspots
- Category distribution
Here I made another cost-focused decision.
StreetPulse does not automatically invoke Bedrock every day just because a schedule fired.
If there are too few reports, the daily narrative is generated deterministically.
When there is enough new information and AI summaries are enabled, the Lambda sends only compact structured report summaries to Amazon Nova Lite.
The resulting City Pulse is then stored in DynamoDB.
That means opening or refreshing the website does not generate another Bedrock request. The frontend simply reads the stored Pulse history.
Over time, StreetPulse can begin answering a more interesting question than "What was reported?"
It can start answering:
What is the city telling us today?
The AWS architecture
StreetPulse currently runs using a predominantly serverless AWS architecture.
AWS Amplify Hosting
Hosts the static Next.js and React frontend.
Amazon API Gateway
Provides the HTTP API used by the web application.
AWS Lambda
Handles API routing, validation, presigned upload generation, report processing, community clustering, report retrieval and Daily City Pulse generation.
Amazon S3
Stores uploaded civic issue photographs privately.
Public access is blocked and the application uses short-lived presigned URLs for uploads and image access.
Amazon Bedrock with Amazon Nova Lite
Performs multimodal analysis of uploaded civic issue images.
Nova can also create a concise Daily City Pulse narrative when enough new report data exists.
Amazon DynamoDB
Stores structured reports, community signal information and Daily City Pulse history using on-demand capacity.
Amazon EventBridge
Triggers the Daily City Pulse workflow once per day.
Amazon CloudWatch
Collects logs from the Lambda functions for monitoring and troubleshooting.
The application is deployed in us-east-1.
Designing around cost instead of ignoring it
One of the things I wanted to avoid was building an AI demo that looked inexpensive until someone actually used it.
StreetPulse therefore tries to keep model calls very deliberate.
Amazon Bedrock is not called for:
- Opening the homepage
- Rendering the map
- Reading reports
- Reading Pulse history
- Calculating map distance
- Community clustering
- Demo records
- Basic statistics
For normal report creation, Nova is called only after a valid image has been uploaded and the report is actually submitted.
For the Daily City Pulse, AI is used only when there is enough new information to justify it.
The rest of the application relies on serverless, pay-per-use services and there is no continuously running EC2 instance or database server behind StreetPulse.
Demo data and real reports
Because StreetPulse is a showcase project and not an official municipal system, I did not want sample reports to appear as if they were real citizen complaints.
The application therefore opens with clearly identified demo data that allows visitors to explore the interface immediately.
A separate Live experience reads reports and Pulse history stored in AWS.
This separation turned out to be useful both for the demo and for responsible presentation of the project.
What I learned while building StreetPulse
The biggest lesson from this project was that integrating an AI model was only one part of building an AI application.
The more interesting questions came afterwards.
How should model output be validated?
Which decisions should not use AI at all?
How can repeated observations become useful intelligence?
How do I make uploaded images useful without making them unnecessarily public?
How can an autonomous feature exist without repeatedly spending money?
How should demo data be presented without pretending it is real?
And how do you build an AWS architecture where every service exists because the product needs it rather than because the architecture diagram needs another icon?
StreetPulse changed considerably while I worked through those questions.
What started as an AI-powered civic reporting idea eventually became something I find much more interesting: a system where individual observations can accumulate into a history of how a place is changing.
Try StreetPulse
Live application
GitHub repository
The repository includes the project architecture, deployment information, cost guardrails, responsible AI notes, usage instructions, and the technical decisions behind the build.
Inspiration
I also want to give a shout-out to @Lewis Sawe and The Museum That Grows.
What I found especially interesting about that project was not simply that an agent could generate something autonomously. It was that each new output became part of a growing history.
That idea stayed with me while working on StreetPulse and influenced how I thought about the Daily City Pulse.
A city's story should not disappear every time the page refreshes.
It should accumulate.
Thank you to @Ben Fowler and the AWS Builder Center team for the Summer Build Series and for creating a reason to turn an idea into something real.
StreetPulse is still a small experiment compared with the scale of the problem it explores, but the core idea now works:
Someone sees a problem.
They create a signal.
Other nearby reports strengthen that signal.
StreetPulse remembers it.
And over time, those signals begin to describe the city itself.
StreetPulse
A City That Tells You Where It Hurts.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article