CivicLens

• 

• 

• 

• 

• 

• 

Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for CivicLens

CivicLens

Inspiration

Local government decisions shape everyday life. They determine whether a park receives funding, where new housing can be built, which library hours are reduced, how streets are redesigned, and when residents can speak before a decision becomes final.

The problem is that this information is technically public but practically inaccessible. It is scattered across long budget PDFs, zoning notices, meeting packets, transcripts, recordings, and municipal websites designed for compliance rather than understanding. Most residents do not have time to read hundreds of pages or watch a three-hour council meeting. They often learn about a decision only after the public-comment deadline has passed.

That gap inspired CivicLens.

The name combines Civic, representing citizens and local government, with Lens, a tool that brings clarity to something difficult to see. Our guiding idea is simple: democracy does not only suffer when information is hidden. It also suffers when important information is published in forms that almost no one can realistically understand or use.

What It Does

CivicLens is an AI-powered local government transparency platform. It acts as a personal civic analyst rather than a general-purpose chatbot.

Residents can upload a city budget, zoning notice, meeting packet, agenda, or minutes PDF. CivicLens validates the document and turns it into a structured civic briefing with:

• an executive summary;
• exact key facts and financial amounts;
• a plain-English explanation;
• important dates and deadlines;
• concrete resident action items;
• affected neighborhoods and services;
• proposal-versus-approval status.

Residents can also set a home address, choose topics they care about, and configure an alert radius. CivicLens then explains why a document matters to that specific resident. For example, it can identify that a proposed zoning change is within the resident's five-kilometer radius, matches their housing and parks interests, and has a public-comment deadline approaching.

The platform also includes:

• a personalized civic alert inbox;
• searchable meeting transcripts;
• agenda-item summaries with decisions and votes;
• extracted financial amounts;
• civic document search with type, date, and location filters;
• an administrator console for configuring and observing municipal scrapers.

For reproducible judging, CivicLens includes realistic fictional government records and deterministic fixture analysis. When an OpenAI API key is configured, the upload endpoint uses GPT-5.6 through the Responses API and identifies the response as live analysis.

How We Built It

CivicLens is a full-stack TypeScript application built with React 19, Vinext, Vite, and Next-compatible App Router conventions. It compiles to a Cloudflare Worker-compatible server and is deployed through OpenAI Sites.

The application contains twelve product routes covering the complete resident and administrator journey:

• homepage;
• sign-in and registration;
• resident dashboard;
• document library and document analysis;
• meetings and meeting intelligence;
• personalized alerts;
• profile and interests;
• civic search;
• administrator scraper controls.

The document-analysis API performs several checks before any AI request:

1. confirms the file has a PDF extension;
2. enforces a 50 MB size limit;
3. verifies the %PDF- file signature;
4. sends the validated PDF with resident context to the OpenAI Responses API;
5. constrains the response with strict JSON Schema;
6. returns a structured civic document to the interface.

Our prompt design protects the facts most likely to cause harm if changed: dollar amounts, percentages, dates, addresses, case numbers, vote tallies, deadlines, and whether an item is proposed or approved. Separate prompts cover document extraction, plain-English rewriting, action items, meeting summaries, relevance scoring, and scraper triage.

We also designed a production persistence model with Drizzle ORM and Cloudflare D1. It includes users, profiles, interests, documents, summaries, meetings, agenda items, alerts, scrapers, and background jobs. The hackathon deployment keeps interactive state session-based for predictable judging, while the schema and migration document the path to durable storage.

To make evaluation concrete, we generated three polished sample PDFs:

• a seven-page city budget excerpt;
• a three-page zoning notice;
• four pages of city council meeting minutes.

Each fixture contains exact amounts, deadlines, votes, and decision status that judges can compare directly with the CivicLens output.

Challenges We Faced

Preserving civic facts

Summarizing a government document is not enough. CivicLens must not turn a proposal into an approval, change a deadline, or simplify away an important funding condition. We addressed this with protected fact classes, explicit uncertainty behavior, strict structured output, and exact-fact acceptance tests.

Personalization without inventing relevance

It is easy to claim that every local document matters to everyone. That would create noise rather than transparency. We designed relevance around verified distance, named-area overlap, selected interests, direct service impact, recency, and open deadlines. Topic overlap alone cannot produce a high score.

Building a complete product instead of a chatbot

The platform needed to support a real civic workflow: discover a record, understand it, determine personal relevance, inspect evidence, and act before a deadline. This required coordinated document, meeting, alert, search, profile, and administrator experiences rather than a single chat screen.

Creating trustworthy demonstration data

Using real municipal documents could introduce changing links, privacy concerns, and difficult-to-reproduce model output. We created realistic fictional records that are visibly labeled as fixtures. This lets judges verify every protected fact without mistaking the files for official City of Austin publications.

Honest live-AI boundaries

We did not want a missing API key or service error to look like a successful live GPT response. CivicLens labels responses as live or fixture. If a configured live request fails, the API returns a visible error instead of silently substituting demo content.

Cross-platform build and deployment

We worked through Vinext production builds, Cloudflare Worker output, Windows Git ownership protections, Docker packaging, PDF rendering, and Sites deployment requirements. The final repository includes automated structure checks, Docker configuration, a production health endpoint, and a detailed deployment checklist.

What We Learned

We learned that AI civic infrastructure needs a higher standard than ordinary text summarization. The most useful output is not the shortest summary. It is the briefing that preserves decision status, explains who is affected, surfaces the deadline, and gives the resident a supported next step.

We also learned that personalization is as important as summarization. A resident does not need every city update. They need the few decisions that match their location, interests, services, and remaining opportunity to participate.

Structured outputs made the application substantially more reliable. They gave the interface a stable contract and made it possible to test exact amounts, dates, votes, and deadlines rather than evaluating summaries only by appearance.

Finally, we learned the value of transparent demo boundaries. Clearly identifying fictional fixtures, simulated scraper runs, session-based state, and live-versus-fixture AI makes the project more credible, not less.

Accomplishments We Are Proud Of

• Built a cohesive twelve-route civic product rather than a chatbot prototype.
• Created structured GPT-5.6 PDF analysis with strict fact-preservation rules.
• Connected documents to a resident's address, interests, radius, and deadlines.
• Built searchable meeting intelligence with attendance, decisions, votes, actions, and financial extraction.
• Created realistic and independently verifiable judge fixtures.
• Added eleven relational database models and a generated migration.
• Added Docker, health checks, automated submission verification, and deployment documentation.
• Passed the complete production build, lint, PDF verification, and all automated acceptance tests.
• Deployed the application through OpenAI Sites.

What's Next

The next phase is to connect the completed experience to durable and continuously updated civic data.

Planned work includes:

• binding D1 or PostgreSQL for persistent users, documents, alerts, and jobs;
• storing uploaded PDFs and meeting media in private object storage;
• adding queue workers for OCR, transcription, analysis, and alert delivery;
• crawling official municipal sources with scheduling, deduplication, and audit logs;
• delivering email and push notifications;
• adding transparent citations from every summary fact back to the source page or transcript timestamp;
• evaluating GPT-5.6 across a large benchmark of budgets, zoning cases, agendas, minutes, ordinances, and scanned records;
• supporting more cities through configurable municipal source adapters.

Our long-term goal is for CivicLens to become a reusable transparency layer for any city: no spam, no noise, just the local decisions that matter, explained clearly while residents still have time to act.

Built With

• 19
• api
• app
• cloudflare
• compose
• css3
• docker
• drizzle
• gpt-5.6
• html5
• next.js
• node.js
• openai
• orm
• pypdf
• react
• reportlab
• responses
• router
• sites
• typescript
• vinext
• vite
• workers