Inspiration

Secondhand smoke is more than an inconvenience. It affects public health, comfort, and the safety of shared spaces such as bus stops, campuses, parks, restaurants, and other public areas. While many places prohibit smoking, people often have no way to know whether an area is currently affected before they arrive.

We built Kabut to help communities identify and share information about areas impacted by cigarette smoke in real time. Instead of relying on static reports or manual monitoring, Kabut enables the community to collaboratively report and verify smoke hotspots, creating a more informed and healthier environment for everyone.

What it does

Kabut is a community-driven mobile application that allows users to report locations affected by cigarette smoke and view nearby smoke hotspots on an interactive map.

Key features include:

Community reporting of cigarette smoke hotspots
Real-time hotspot visualization
Grid-based hotspot aggregation to combine nearby reports
Community verification through Clean Votes
Trust Engine to reduce false or malicious reports
Automatic hotspot lifecycle management based on community activity
Real-time synchronization between users

Kabut helps users make informed decisions about where to spend their time while encouraging community participation in maintaining healthier public spaces.

How we built it

Kabut was built as a cross-platform mobile application using modern technologies:

React Native (Expo SDK 54)
TypeScript
Supabase
PostgreSQL
Supabase Realtime
Edge Functions

One of the core components is our Trust Engine, which validates incoming reports before they affect the map. This helps reduce spam and false reporting while maintaining data quality.

We also implemented a Grid-based Hotspot Aggregation system. Instead of displaying every report individually, nearby reports are grouped into a single hotspot, improving both map readability and application performance.

To ensure hotspots remain accurate over time, users can submit Clean Votes when an area is no longer affected. The hotspot score is recalculated automatically, allowing outdated hotspots to disappear only after sufficient community confirmation.

Challenges we ran into

One of the biggest challenges was balancing openness with reliability.

Allowing anyone to submit reports increases community participation but also introduces the risk of false reports and spam. Designing a Trust Engine that filters unreliable reports while keeping the reporting process simple required several iterations.

Another challenge was implementing real-time synchronization across all users without sacrificing performance. Efficiently updating map markers while preventing duplicate hotspots required us to design a grid-based aggregation system rather than storing every report as an independent marker.

Determining when a hotspot should disappear was also more complex than expected. We needed a system that prevented a single user from immediately removing a hotspot while still allowing communities to confirm when an area was clean again.

Accomplishments that we're proud of

Designed and implemented a Trust Engine to improve report reliability.
Built a Grid-based Hotspot Aggregation system that keeps the map clean and scalable.
Implemented community-driven hotspot verification using Clean Votes.
Achieved real-time synchronization between users.
Developed a complete end-to-end reporting workflow from submission to hotspot visualization.

What we learned

Building Kabut taught us that technical challenges are only part of creating a successful community platform.

We learned that trust, verification, and data quality are just as important as real-time functionality. Designing systems that encourage participation while preventing abuse requires careful consideration of both user experience and backend architecture.

We also gained valuable experience in building scalable geospatial applications, implementing real-time synchronization, and designing backend systems that can evolve as community participation grows.