CircleSafe

Inspiration

Safety apps often focus on either tracking where someone is or broadcasting incidents to a large public audience. I wanted to explore something more personal: what if safety information could be shared directly with the people you already trust?

CircleSafe was inspired by the way friends already look out for each other—warning each other about something happening nearby, sharing locations when traveling alone, or asking someone to make sure they get home safely. I wanted to bring those behaviors into one shared, map-based experience.

What it does

CircleSafe is a social safety map for trusted groups of friends, or "Circles."

When a Circle member witnesses or learns about a safety threat, they can report it and mark its exact location on the shared map. Other members see the incident on their own map along with AI-generated safety and location context.

Circle members can interact with reports by indicating that they are nearby, helping the group understand when someone may have firsthand awareness of what is happening.

CircleSafe also includes Watch Me. A member can start a temporary Watch session that becomes visible to the rest of their Circle. Another member can open the session and follow that person's live location and movement path on the map. When the person ends Watch Me, location sharing stops and the watcher session automatically closes.

The goal is not just to show where your friends are, but to give trusted groups a shared picture of what is happening around them and a way to actively look out for one another.

How I built it

I built the iOS application natively with Swift and SwiftUI. MapKit powers the shared incident map and live Watch Me visualization, while Core Location provides temporary location updates during an active Watch session.

The app communicates with a Node.js/Express backend through REST APIs. MongoDB stores shared incidents, Circle responses, Watch sessions, and temporary Watch location data.

I integrated AI APIs to transform submitted incident information into more useful safety and location context rather than displaying only the original report.

For Watch Me, the device that starts a session sends location updates to the backend. Other Circle members periodically receive the updated session data and render the member's latest position using MapKit. Received coordinates are also used to create a visible movement trail, allowing a friend to follow the member's progress in real time.

Challenges I ran into

One of the biggest challenges was synchronizing state between multiple devices. Early versions updated immediately on the phone performing an action, but another phone would not see the change until the app was restarted.

I solved this by introducing periodic synchronization with the backend so incident responses, Watch sessions, and location updates propagate between devices.

Live location introduced another challenge. I had to coordinate Core Location permissions, simulated GPS locations, backend updates, and SwiftUI state. At one point, the backend was correctly receiving new coordinates while the watcher's marker remained in its original position because the local Watch session was only being replaced when its ID changed. Updating the session on every refresh allowed SwiftUI to react to changing coordinates.

Testing with multiple iPhone simulators was especially useful because it allowed me to simulate two Circle members interacting with the same shared data and even simulate one member moving while another watched.

Accomplishments that I'm proud of

I'm especially proud that CircleSafe became a genuinely multi-user experience rather than just a map interface.

An incident created on one device appears on another. Circle responses synchronize between devices. A Watch Me session started by one member becomes visible to another member, who can open it and follow the first member's live location and movement trail. Ending the Watch session also propagates to the watching device.

Seeing those interactions work across two independent simulators was an important milestone because it demonstrated the core idea behind CircleSafe: friends actively looking out for each other through shared information.

I'm also proud that I was able to build the project across multiple parts of the stack—from the native iOS interface and location services to the backend, database, APIs, AI integration, and cross-device synchronization.

What I learned

I learned that building social features involves much more than designing the interface. Shared state has to remain consistent across devices, and even seemingly simple interactions become distributed-system problems once multiple users are involved.

I also gained experience with SwiftUI state management, MapKit, Core Location, MongoDB, asynchronous networking, and debugging communication between a native iOS application and a backend.

Most importantly, I learned that technology for personal safety can be more useful when it strengthens existing relationships rather than trying to replace them. CircleSafe became less about tracking people and more about helping trusted friends share context and actively look out for one another.

What's next for CircleSafe

The next step is expanding Circles into a more complete social safety network. I want to introduce proper user accounts and Circle membership, stronger identity and permissions for Watch Me sessions, push notifications for relevant incidents and Watch requests, and more control over exactly who can see shared information.

I would also like to improve Watch Me with richer trip information, arrival confirmation, and more efficient real-time updates instead of polling.

Longer term, CircleSafe could incorporate additional verified information sources alongside community reports while clearly distinguishing where each report came from. My goal is to make the shared map increasingly useful without losing the private, trusted-group experience at the center of CircleSafe.

Built With

• core-location
• express.js
• geminiapi
• mapkit
• mongodb
• node.js
• openaiapi
• react
• restapi
• swift
• swiftui
• typescript