AWS Builder Center
A Civic App Is Easy to Demo. Building One People Can Trust Is Harder.

A Civic App Is Easy to Demo. Building One People Can Trust Is Harder.

Building MERAWARD taught us that civic technology is not just about reporting problems. It is about reducing friction, handling imperfect public data honestly, and designing systems that citizens can understand and trust.

Software Engineer | AI/ML & Cloud Enthusiast | Open Source Contributor | Builder
A person sees a broken streetlight.
Or a road filled with potholes.
Or garbage piling up outside their neighbourhood.
They take out their phone, search for where to report it, open a government website, find three different departments, and eventually give up.
Not because the problem is unimportant.
Because the process is exhausting.
That was the problem we wanted to explore with MERAWARD, a civic accountability platform we built during First Commit, part of the Bharat Builds Tour by WeMakeDevs and AWS Builder Center.
We started with a simple question:
What if reporting a civic issue felt as easy as sending a message?
But as we began building, we realised that the problem was much bigger than creating a complaint form.
It involved location, administrative boundaries, language, trust, accessibility, public data, and what happens after a complaint is submitted.

Start with the citizen, not the department

Most systems are designed around how organisations are structured.
Citizens, however, do not think in terms of departments, jurisdictions, or administrative hierarchies.
They think:
“There is a problem outside my house. Who can fix it?”
That difference shaped our product decisions.
Instead of asking users to first understand the government structure, MERAWARD begins with something more natural: Where are you?
Users can identify their municipal ward through GPS or by dropping a pin on the map. The platform then uses that location to provide relevant administrative context and guide them toward the appropriate reporting flow.
The citizen should not have to become an expert in municipal boundaries before reporting a broken road.

Three ways to explain one problem

People do not all communicate in the same way.
Some prefer typing. Some would rather speak. Others already have a photograph that explains the situation better than a paragraph ever could.
So we built three reporting options:
  • Speak
  • Photo
  • Write
The input can then be converted into a formal complaint draft in Hindi and English, addressed to the relevant ward office.
The user can review and edit the draft before submitting it.
This was important to us because accessibility is not just about font sizes and colour contrast. It is also about allowing people to express themselves in the way that feels most comfortable.
A resident should not need polished formal language to report an overflowing drain.

Removing friction matters

Every additional step in a public-facing product creates another opportunity for someone to abandon the process.
That made us question several familiar patterns.
Do users really need to create an account before reporting an issue?
Do they need to understand which department handles sanitation versus roads?
Do they need to write a perfectly structured complaint?
Do they need to navigate five pages before reaching the actual reporting action?
For the initial experience, we chose to keep the process lightweight.
Users can begin reporting without being forced through a lengthy signup flow. The reporting interface is mobile-first, because a civic issue is far more likely to be noticed while someone is outside than while they are sitting at a desktop.
These may look like small design decisions.
But small decisions determine whether a product feels usable or bureaucratic.

Accountability needs visibility

Reporting a complaint is useful.
Knowing what happens to complaints over time is even more useful.
That is why MERAWARD includes a public dashboard showing complaint activity and a Ward Neglect Index.
The index looks at factors such as:
  • Unresolved complaint volume
  • How long complaints remain open
  • Historical resolution speed
But we did not want to create a dashboard that looked authoritative while quietly making unreliable assumptions.
For example, a ward with only one or two reports should not automatically receive a perfect score. A lack of data is not the same thing as good performance.
So wards with fewer than five reports receive no score instead of being treated as well-managed.
The score also applies to a ward, not an individual official.
That distinction matters.
The purpose is to identify patterns and make civic conditions more visible, not to make personal accusations based on incomplete information.

The uncomfortable part: public data is messy

One of the biggest lessons from building MERAWARD was that civic technology depends heavily on data that developers do not control.
Administrative boundaries can be outdated.
Different sources can disagree.
Public records may be incomplete or difficult to access.
Information that looks straightforward on paper can become surprisingly complicated once you try to build a real product around it.
We spent considerable time validating ward boundaries, checking known locations, cleaning geographic data, and testing whether the map placed users in the correct administrative area.
That work was not particularly glamorous.
There was no flashy interface to show for it.
But if the system identifies the wrong ward, everything that follows can be wrong too.
The complaint may go to the wrong office. The dashboard may attribute activity to the wrong area. The accountability layer begins with a faulty foundation.
That led to one of our strongest conclusions:
In civic technology, data quality is not a backend detail. It is a user experience problem.

Delhi was our starting point, not our boundary

We used Delhi for the initial implementation because a hackathon requires a manageable scope and a defined geography.
It gave us a practical place to test the complete workflow:
  1. Identify a ward
  1. Report a civic issue
  1. Generate a complaint
  1. Track complaint activity
  1. Visualise ward-level patterns
But the problems we were addressing are not unique to Delhi.
Different cities may have different administrative structures, local languages, boundary datasets, and reporting channels. The product therefore needs to be adaptable rather than built around one fixed geography.
Our larger ambition is to make MERAWARD useful across cities and municipalities in India, adding regions as reliable local data becomes available.
The map may change.
The underlying experience should not have to.

Designing for trust, not just functionality

A civic platform has a different responsibility from an ordinary productivity app.
If a music app gets a recommendation wrong, the consequence may be minor.
If a civic platform sends a complaint to the wrong office or presents incomplete data as fact, it can mislead people and reduce trust.
That is why we made several choices deliberately:
  • We distinguish demo data from real-world records.
  • We avoid presenting insufficient data as a definitive score.
  • We keep the Ward Neglect Index focused on areas rather than individuals.
  • We allow users to review generated complaint drafts.
  • We are transparent about the limitations of the current dataset.
  • We treat expansion as a data and governance challenge, not just a deployment task.
Trust is not something a product can add at the end with a disclaimer.
It has to be designed into the experience from the beginning.

What we learned

Building MERAWARD during a hackathon was not just an exercise in shipping features quickly.
It was an exercise in deciding what not to pretend.
We could have filled the dashboard with confident-looking numbers.
We could have hidden data limitations behind a polished interface.
We could have made the product appear larger than its current coverage.
Instead, we tried to build a foundation that was useful, explainable, and honest about what it could and could not currently do.
MERAWARD is still an early implementation.
But the direction is clear.
We want civic reporting to feel less intimidating, administrative responsibility to feel less invisible, and public data to become something citizens can actually use.
Delhi was where we began.
The ambition is much bigger: a civic accountability platform that can adapt to cities across India, one reliable dataset and one thoughtful product decision at a time.
Because a civic app should not merely help people submit complaints.
It should help them feel that their complaint has somewhere meaningful to go.



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