AIdeas: Orbits - The Ultimate Social Life Manager
My friend and I are building Orbits to be a living map of your social life.
App category: Daily Life Enhancement
Team Members: @devaziouziou
Human connection does not fit neatly into a contact list or a calendar app. Orbits is our attempt to offer people a way to organize and manage social life in a way that still aligns with human psychology.
My Vision
"The single most important factor affecting your mental health and well-being, your physical health and well-being, and even how long you're going to live into the future from today on... is the number and quality of friendships you have." — Robin Dunbar
Orbits is inspired by the work of Robin Dunbar. Dunbar is an evolutionary psychologist famous for creating the Dunbar Number — a cognitive limit to the number of people you can maintain a stable social relationship with, about 150 people. He also influenced the model that states that your social circles are a layered system that consists of something along the lines of:
- Inner circle
- Close friends
- Casual friends
- Acquaintances
- Bigger network
This layered model is proven to match real social life, but almost no app is built around it. That is why we wanted it to become the foundation of Orbits. People orbit us at different frequencies, levels of closeness, and intensities — hence the name Orbits.
Orbits is designed to act as a social map of real human relationships.
At its core, the app is a social life operating system designed to help people manage relationships more intentionally. It gives users a way to:
- See the people in their life
- Organize them by closeness and context
- Keep track of the moments that matter
- Surface meaningful next actions before important relationships drift into the background
But mapping social life is not just about mapping people. Relationships do not exist in isolation. They live inside life contexts, shared routines, places, and moments. A friend from your gym does not play the same role as a childhood friend, and a recurring dinner or trip can matter just as much as the relationship itself. That is why, beyond the orbit model, I wanted Orbits to reflect social life as it actually happens in the real world. This led to one of the main product design decisions: building the system around Connections, Worlds, and Events.
Connections
Connections are the core of Orbits. They represent the people in your universe — the WHO behind everything else. It is not just storing contacts, but allowing you to model closeness, context, cadence, and momentum.
Connections are visualized through the orbit model — concentric rings inspired by Dunbar-style social layers. Inner rings mean higher closeness, more importance, and usually more upkeep. Outer rings mean lighter touchpoints and lower maintenance. The user can also rename rings to match how they actually think: Inner Circle, Close Friends, Tribe, Allies, Acquaintances, Gang, and so on.
Connections also hold the practical layer that makes the system useful: relationship type, preferred communication style, location, notes, origin story, reminders, and custom fields.
Interactions
An Interaction is a meaningful touchpoint with a Connection. It can be a dinner, a walk, a text exchange, a group hangout, a call, a trip, or anything else that actually moves the relationship forward.
This was important to separate from the person itself. It captures what happened, through which channel, how meaningful it was, and any notes worth remembering next time. Interactions also feed the rest of the system: they can update cadence, enrich memory, attach to Worlds and Events, and create follow-up hooks that make future suggestions more grounded.
Key principle: Orbits shouldn’t expect the user to log every coffee or hangout. The intelligence behind it is designed to allow for easy logging and inference.
Cadence
Cadence is the keep-in-touch rhythm of a relationship. It answers a simple question: are we on track, drifting, or overdue?
I did not want this to be a single “last contacted” field because real life is more situational than that. Someone can be on track virtually but drifting in person, and that can still be perfectly normal. So cadence can adapt to the shape of the relationship: who lives nearby, who lives abroad, who you see daily, who only makes sense in certain seasons or contexts.
Worlds
This is one of the principles unique to Orbits.
A World is a recurring context in your life where certain people, places, and activities cluster. Worlds connect Connections and Events into a coherent “part of your life”.
Worlds can represent different kinds of life contexts:
- Groups: work team, childhood friends, university crew
- Places: gym, a specific café, a city, a neighborhood
- Themes: music, hiking, travel, boxing, developer
Why “World”? Because it describes a complete slice of life that you can step into — “My Surfing World”, “My Band World”, “My Work World”, “My Gym World”, “My Madrid World.”
They can have their own members, memories, recurring places, event templates, goals, rituals, and even their own kind of momentum.
How Worlds connect to the rest of Orbits:
- Every Event belongs to a World
- A Connection can belong to multiple Worlds
Events
An Event is a time-bound moment you can plan and remember. It is the space where Orbits helps you:
- organize future plans
- journal past moments
- maintain recurring Gravity Wells — repeatable events that create momentum in a World
Events connect naturally to Connections (attendees) and Worlds (life context).
An Event can be small, like dinner or coffee, or big, like a trip, wedding, festival, or retreat. Some are about coordination and planning. Others are about memory and reflection. The idea is that events should not just live as calendar entries ; they should become part of the social map and strengthen the worlds and relationships they belong to.
Signals
This is where the AI shines. On top of the structure, Orbits has a softer layer of Signals. These are lightweight social-intelligence attributes that help the app understand how a relationship feels.
The main ones are:
- Ground → reliability, trust, consistency
- Vibe → emotional tone and energy
- Flow → how naturally you click, coordinate, or move together
- Energy → Social energy input/output
These are not moral labels, verdicts, or hard scores. They are observations so the system can make smarter suggestions without becoming judgmental, manipulative, or weird.
The "What’s Next"
Once Connections, Interactions, Cadence, Worlds, Events, and Signals exist, AI is also used in What’s Next.
What’s Next is the layer that suggests the next meaningful move based on who the person is, what world they belong to, how recently you interacted, what might be drifting, what is coming up soon, and what the user is actually trying to build in their social life.
That could mean:
- checking in with someone
- inviting someone to something
- following up on a past conversation
- reviving a world that has gone quiet
- planning an event
Why This Matters
When life gets busy, relationships quietly decay.
Not because we stop caring, but because social life becomes reactive. We reply to whoever shows up, forget to follow up, and let important people slowly drift into the background. A few missed moments turn into distance → a few busy months turn into silence → keep it this way and loneliness is an issue you have to potentially deal with.
That is the problem Orbits is trying to solve.
For me, the value of Orbits comes down to two things:
- Visibility — the ability to actually see the core elements of your social life
- Intention — the ability to set, maintain, grow, and manage those relationships on purpose
Orbits is a living social map. It helps you see the people in your life, the worlds they belong to, and the moments that keep those relationships alive. Once that becomes visible, acting with intention becomes much easier than leaving everything to scattered notes, plain memory, luck, or whoever texts first.
That matters because most of us do not really have a proper home for social life:
- Social media is not a real reflection of our relationships. Our life is scattered across apps. Some people are on WhatsApp, some on calls, some barely use social media.
- Existing tools miss the point: they either feel too transactional, like a CRM, or too blunt, like using a calendar or Excel to manage people.
Orbits is built for people who want to be more intentional socially, whether that means:
- Maintaining a strong inner circle
- Growing a meaningful network
- Managing a busy social life without losing track of what matters
- Staying connected across different life chapters, interests, cities, and routines
- Creating more memories, traditions, and recurring moments with the right people
And for the skeptics, including me at first — this only works if it stays grounded. Orbits is not here to judge people, label them, or replace human judgment. The point is simpler: help people see their social life more clearly, and give them a better way to show up for the people who matter.
How I Built This
With the magic of computer science, Prog Rock albums (ping for recommendations), caffeine, and our friend Kiro.
The Stack
- Python 3.11 for all backend logic
- AWS Lambda for compute (9 specialized functions)
- DynamoDB for data storage (single-table design with GSIs)
- API Gateway for REST endpoints
- SQS for async AI processing
- AWS Bedrock (Claude Haiku) for AI suggestions
- Pydantic for data validation
- Hypothesis for property-based testing
- Next.js for the frontend
Some Technical Decisions Worth Mentioning
The hardest part of building Orbits was not the code. It was the data model. Social life is messy. If the underlying structure does not reflect that, the app either becomes too rigid or too vague. Most of the early weeks were just me asking: what are the real objects here? What connects to what?
This led to the three-layer architecture: Connections, Worlds, and Events. Every time I tried to simplify further, something broke. Remove Worlds and relationships lose context. Remove Events and there is no sense of time or momentum. Remove Connections and you are just building a calendar.
The Product Architecture looks something like this:
Serverless by Design
We built Orbits on AWS serverless infrastructure. The system scales automatically and costs almost nothing to run.
1
2
3
User → API Gateway → Lambda Functions → DynamoDB
↓
SQS Queue → AI Worker → AWS Bedrock (Claude)
Why serverless? Because we wanted to focus on building features, not managing servers. Lambda functions handle all the logic, DynamoDB stores everything, and the whole thing runs on AWS's free tier for the first users.
The Data Model
DynamoDB is a NoSQL database that we explored in this project, which means we had to think differently about data modeling. We use 4 specialized tables:
- ConnectionsTable — Connections, Worlds, Events, memberships, and attendees
- InteractionsTable — Interaction logs (kept separate for query performance)
- AISuggestionsTable — Pending AI suggestions awaiting approval
- AICacheTable — Cached AI responses (with TTL for auto-cleanup)
The ConnectionsTable uses a multi-entity pattern where different entity types share the same table with clever key patterns. This means we can answer complex questions like "Show me everyone I'm drifting from who I usually see in person" with a single query.
Why separate tables? Interactions have different access patterns (time-series queries) and could grow large. AI Suggestions are temporary and frequently updated.
The Intelligence: AI That Suggests, Does Not Decide
Example Workflow: When you log an interaction with notes, the AI is triggereed.
- User logs interaction with notes
- Lambda saves to DynamoDB and queues the notes to SQS
- AI Worker picks up the message asynchronously
- Claude Haiku (via AWS Bedrock) suggests memory items, signal tags (ground, vibe, flow), and follow-up actions
- Suggestions stored as "pending" — you approve or reject them
- Approved suggestions update the Connection automatically
The key insight: AI does not make decisions. It suggests. You stay in control.
We cache AI responses to avoid redundant API calls, and the whole process happens in the background so the app stays reasonably fast.
The Cadence Engine
One of the hardest problems was modeling relationship cadence. How do you know when a friendship is drifting?
We track two independent cadences:
- Virtual cadence: texts, calls, video chats
- In-person cadence: coffee, dinners, hangouts
This powers the "What's Next" feature — a ranked list of who needs attention, sorted by urgency and relationship importance.
The World System
Worlds were the trickiest feature to design. They needed to be flexible enough to represent groups, places, and themes, but structured enough to be useful.
We decided that a World contains:
- Members (Connections with membership levels)
- Goals (what you are building toward)
- Milestones (what you have achieved)
- Event Templates (recurring patterns like "Sunday brunch")
- Shared Assets (notes, links, locations, rituals)
- Journal Entries (reflections on the World)
Worlds also track their own cadence — when was the last activity with anyone in this World? This lets Orbits suggest things like "Your Gym World is drifting, maybe plan a workout with someone?"
The Event System
Events come in three types:
- Future Events — plans you are making
- Memory Capsules — past moments you want to remember
- Gravity Wells — recurring events that create momentum
When you complete an Event, Orbits can automatically generate interactions for attendees, update cadences, suggest follow-up events, and create world-level insights. Events connect to Worlds (context) and Connections (attendees), creating a web of relationships and moments.
Testing Strategy
Kiro suggested using Python's Hypothesis for property-based testing, which generates hundreds of random tests to find edge cases we would not think of manually. We also have 65+ unit tests covering specific scenarios, plus integration tests for cross-system flows. Thanks Kiro :)
Deployment: Infrastructure as Code
Everything is defined in AWS SAM, which means we can deploy the entire backend with one command:
This created:
- 9 Lambda functions
- 4 DynamoDB tables
- 1 API Gateway (REST with CORS)
- 2 SQS queues (AI processing + dead-letter queue)
- CloudWatch log groups (30-day retention)
- IAM roles and policies (least-privilege access)
All automatically configured and connected.
The Cost: Almost Free
Thanks to AWS free tier:
- Lambda: 1M requests/month free (we use ~50K)
- DynamoDB: 25GB storage + 25 read/write units free
- API Gateway: 1M requests/month free
- SQS: 1M requests/month free
- Bedrock (Claude Haiku): pay per token (~$0.25 per 1M input tokens)
The architecture is also designed to stay cheap while scaling.
AI Guardrails
I spent a lot of time on guardrails. On purpose. The moment you put AI near something like social life, you are one bad label away from making the whole thing feel manipulative or soulless.
Rules I set early:
- no moral labels
- no "toxic" classifications
- no visible scoring of human worth
- no reciprocity accounting
- No self fulfilling biases
The intelligence layer uses signals like Ground (reliability), Vibe (emotional energy), and Flow (compatibility). These stay observational — things the user writes or approves, not things the system decides. They power smarter nudges, better event suggestions, and better routing. Not a friend leaderboard.
Even the Energy Matrix — effort required versus how nourishing it tends to be — is framed as "how should I allocate energy?" not "who is worth it?"
Next Steps
We are currently working on:
- Frontend (Next.js + React)
- Smarter AI worflows
- Calendar integrations
The core is solid. The data model works. The AI is helpful. The cadence engine is accurate. Now we just need to make it beautiful.
What I Learned
Vibe Coding Masterclass: Bringing this idea to life would have been much harder without Kiro. We loved how spec-driven it is. It writes a requirements document, then the design, then the tasks. Starting with context makes it great for incremental building. Also, I found myself digging deeper into bugs, and Kiro was very helpful. Sometimes I caught myself writing, “pls make no mistakes” and thats it.
What this means for engineers. After weeks using Kiro to build a product end to end I realized that AI did not replace the thinking. Architecture, data model decisions, guardrail philosophy; all that was human. AI made execution faster. Knowing what to build still matters more than building it quickly. But, on the other hand, I concluded that AI is definitely going to drastically change how we work as engineers, and the bigger change will come soon, so all of us need to be prepared for that.
Learning the stack by building it. We were mildly familiar with the AWS ecosystem. We knew about Serverless and NoSQL conceptually but had no real hands-on experience. So we learned by doing. Even if Kiro gave the foundation, we still needed to study the concepts. Several times, we asked Kiro to generate separate tutorials on how to use specific technologies in respect to our project. This is Software Engineering today.
Demo
---And the Vibe of using it ----
When I open the /me dashboard, I feel like I’m looking at a quiet map of my social world. I’m at the center, and around me the people in my life appear as small planets orbiting at different distances depending on how close we are. The whole interface feels calm and almost cosmic, with soft colors and rings that make relationships look alive instead of like rows in a table. On the sides, I can quickly see the pulse of my relationships — who I’ve been keeping up with, who might be drifting away, and small suggestions of what I could do next.
When I open the /connections page, it feels like stepping into the actual list behind the universe I saw on the dashboard. Here I can clearly see the people in my network as individual cards, each one showing who they are, where they are, and the current state of our relationship. I can quickly understand how strong the connection is through simple indicators like Ground, Vibe, and Flow, and also see when I last interacted with them. It doesn’t feel like managing contacts in a typical app — it feels more like observing the health of real relationships.
When I open a specific connection, it feels like zooming into one person in my social universe. Instead of just seeing their name, I get a clearer picture of the relationship itself — how strong it is, when we last interacted, and whether I should reach out again. I can see different aspects of our connection like Ground, Vibe, and Flow, which give a simple but meaningful sense of how we relate to each other. There’s also a timeline of our interactions and small personal details that remind me where we met, how we usually communicate, or things that matter to them. It feels less like a profile and more like a living snapshot of a relationship.
When I open the /worlds page, it feels like seeing the different contexts of my life laid out in front of me. Instead of focusing on individual people, I can see the groups and environments where my relationships exist — friends in a city, people from a project, communities around shared interests. Each world acts like a small cluster that gathers the people connected through that part of my life. I can quickly see how active each world is, how many people are part of it, and whether I’ve been engaging with it recently. It gives structure to my social landscape, helping me understand not just who I know, but where in my life those connections belong.
When I open the /interactions page, it feels like looking at the memory stream of my relationships. Here I can see the small moments that actually build connections over time — calls, messages, meetings, little check-ins that might otherwise disappear from memory. Each interaction is placed in a simple timeline, so I can quickly remember what happened, with whom, and when. Some entries even show small signals about how meaningful the interaction was or whether I should follow up. It’s a quiet but powerful reminder that relationships are really made of these small moments.
When I open the /events page, it feels like the place where relationships turn into real moments. Instead of just tracking people or past interactions, this space helps me plan the things that actually bring us together — a coffee chat, a team sync, dinner with family, small rituals that keep relationships alive. I can create simple templates for these recurring moments so they’re easy to repeat, almost like setting intentions for how I want to show up in my life. It reminds me that relationships aren’t just data or memories, they’re shared experiences that happen in time.
Complete Overview:
You can test the latest version here -> https://orbits-omega.vercel.app/
Final Words
This is obviously still a prototype, but we are genuinely passionate about this idea and we want to keep building it. If it resonates with you, if you have thoughts or feedback, or just want to talk about it — we would love to hear from you.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article