ToGather
Social planning app for groups
Challenge: Synchronizing complex social state across client and backend
Node.js (Express), PostgreSQL, TypeScript
Short walkthrough of creating ideas, turning them into plans, and interacting within a group.
Planning activities with friends is often fragmented across chats, notes, and multiple apps. There is no unified system that supports the full lifecycle from collecting ideas to organizing plans and keeping shared memories afterward.
- Group-based social system with friends and shared spaces
- Idea creation with attributes like budget, mood, and context
- Structured plans with participants and status tracking
- Comments, messaging, and notifications
- Memory features with photos, likes, and comments
Full synchronization for consistent client state
The main challenge was maintaining consistent client state across a complex social system. The app manages interconnected data such as users, groups, ideas, plans, participants, messages, and notifications.
I implemented a full synchronization strategy:
- A central sync function fetches all relevant domain data from the API
- Client state is hydrated from a consistent server snapshot
- Domain data is structured and normalized on the client
On the backend:
- Modular REST API built with Express and TypeScript
- Zod validation for safe inputs
- Transactional database operations to maintain data consistency
This approach prioritizes reliability and consistency over partial updates.
The stack pairs a React Native client with an Express and PostgreSQL backend. Data is loaded through full synchronization from server to client so all social domains stay aligned with one consistent snapshot.
Client
React Native (Expo) with domain-based state and secure token storage.
Server
Node.js + Express API with TypeScript.
Data
PostgreSQL with relational modeling for social interactions. Full synchronization from server to client maintains consistency across all domains.
Key Engineering Decisions
Full-sync strategy instead of incremental updates
Simpler consistency; higher data transfer than fine-grained partial updates.
Domain-driven backend structure
Separates auth, social, plans, and messaging; requires clear contracts at module boundaries.
Server-side validation and ownership checks
Enforces correct state transitions; more server-side logic than trusting the client alone.
Current Limitations
- Full sync increases data transfer compared to partial updates.
- Not optimized for large-scale real-time updates.
- REST-based approach requires additional work for real-time features.
Planned Improvements
- Introduce WebSocket-based real-time updates.
- Add pagination and partial sync for scalability.
- Improve notification delivery and background handling.
- Add automated tests and CI/CD pipeline.