
We Wanted to Make Civic Complaints Easier. We Started With One City.
MERAWARD is a civic accountability platform designed to simplify local issue reporting, connect citizens with the right administrative offices, and make unresolved civic problems more visible. Starting with Delhi as a practical testbed, the platform is designed to expand across cities and municipalities in India.
Every Indian city has a familiar collection of problems.
Broken roads. Overflowing garbage. Streetlights that stop working at exactly the wrong time. Drains that become swimming pools during rain.
And whenever something goes wrong, citizens usually end up asking three questions:
Who is responsible for this? Where am I supposed to report it? Will anything actually happen after I do?
The problem is not always that reporting a civic issue is impossible.
It is that the process often feels like a scavenger hunt involving government websites, unclear departments, outdated contact information, and a generous amount of patience.
That was the starting point for MERAWARD, a civic accountability platform we built during First Commit, part of the Bharat Builds Tour by WeMakeDevs and AWS Builder Center.
We used Delhi as our initial testbed because a hackathon needs a defined geography, usable data, and a problem that can be scoped realistically.
But Delhi was only the starting point.
The problem exists in cities and municipalities across India.
And we wanted to build something that could eventually travel beyond one map.
First, figure out where you are
Before reporting a civic issue, citizens often need to know which ward, office, or administrative body is responsible for it.
That sounds simple until you try doing it.
MERAWARD lets users identify their municipal ward using GPS or a dropped pin on the map. Once the ward is identified, the platform can provide relevant administrative context and guide the user into the reporting flow.
In other words, we wanted to eliminate the classic civic-tech experience of:
“Please contact the correct department.”
Followed by absolutely no indication of which department that might be.
Reporting should not feel like filing paperwork
We designed three ways to report an issue:
- Speak
- Photo
- Write
Users can describe a problem, upload a photograph, or type out what happened.
MERAWARD then turns that input into a formal complaint draft in Hindi and English, addressed to the appropriate ward office. The user can review, edit, and approve the draft before submitting it.
The idea is simple: citizens should spend their time explaining the problem, not figuring out how to phrase an official letter.
We also decided not to force users through a lengthy signup process. A person dealing with a flooded street probably does not want to create yet another account before reporting it.
A complaint should not disappear into a black hole
Submitting a complaint is only one part of the problem.
The other part is visibility.
Can citizens see how many issues remain unresolved? Are complaints being addressed quickly? Are some areas repeatedly dealing with the same problems?
MERAWARD includes a public dashboard with complaint activity and a Ward Neglect Index.
The index considers factors such as:
- The number of unresolved complaints
- How long complaints have remained open
- Historical complaint resolution speed
However, we were careful not to turn limited data into fake precision.
For example, a ward with only one or two reports should not automatically receive a perfect score simply because there is not enough information to identify a pattern.
That is why wards with fewer than five reports receive no score, rather than being treated as perfectly managed.
The score is also assigned to a ward, not to an individual person.
We wanted the system to highlight patterns in civic service delivery, not become a tool for making unsupported personal accusations.
The map was harder than the interface
One of our biggest surprises was that the most difficult part of building MERAWARD was not creating the reporting interface.
It was figuring out where administrative boundaries actually were.
We had to find, inspect, clean, and validate ward boundary data. We tested known locations, investigated geometry issues, and made sure that a dropped pin would not mysteriously place someone in the wrong ward.
Because apparently, even asking “Which ward am I in?” can become a geospatial engineering problem.
For the initial implementation, we used Delhi’s ward boundaries and built a geospatial lookup system using polygon geometry and spatial indexing.
But the deeper challenge was not technical.
It was data reliability.
Finding current, consistent, openly usable civic datasets is difficult. Administrative boundaries change. Public records can be incomplete. Different sources may disagree. Some information is available only in formats that were clearly not designed to be used by developers.
That led us to one of our biggest takeaways:
Civic technology cannot be more transparent than the data it is built on.
Building for one city without getting trapped there
Although Delhi was our starting point, we did not want to build a Delhi-only application with a hardcoded future.
The architecture was designed around reusable components:
- City-specific administrative boundary data
- Modular ward identification
- Configurable complaint workflows
- Separate data and processing layers
- Public reporting and analytics
- Asynchronous processing for heavier tasks
This means the same core workflow can eventually be adapted to other cities and municipalities, provided reliable local data is available.
The goal is not to create one more isolated civic app.
The goal is to create a reusable civic accountability layer that can grow city by city.
What AWS made possible
We built MERAWARD using a serverless AWS architecture, including services such as:
- AWS Lambda for backend logic
- API Gateway for HTTP APIs
- DynamoDB for application data
- S3 for file uploads
- SQS for asynchronous processing
- EventBridge Scheduler for scheduled jobs
- CloudWatch for observability
- Amplify and CloudFront for hosting and delivery
- AWS SAM for infrastructure as code
This allowed us to move quickly without spending the weekend maintaining servers instead of building the product.
It also gave us room to separate user-facing interactions from background tasks such as complaint drafting, file processing, and periodic index recalculation.
For a hackathon project, that separation mattered. For a platform intended to expand across cities, it matters even more.
Starting small, thinking beyond the map
MERAWARD is still an early implementation.
Our current data coverage is limited, some workflows are demonstrated using demo data, and we are transparent about those limitations rather than pretending the system has nationwide coverage overnight.
But that is also the point.
A platform like this does not become useful by claiming to have solved civic accountability for an entire country in one weekend.
It becomes useful by creating a foundation that can be tested, improved, and expanded responsibly.
Delhi was where we began because it gave us a practical place to start.
The larger ambition is India.
We want to make civic reporting easier to access, administrative responsibility easier to understand, and unresolved public problems harder to overlook.
Because citizens should not need detective skills, ten open browser tabs, and unlimited patience just to report a broken streetlight.
And ideally, the next time someone asks:
“Where do I report this?”
The answer should be much simpler.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article