Overview
PetSpot was developed as the capstone project for the 4Geeks Full Stack Development program.
The platform connects pet owners with pet-friendly establishments. Pet owners can discover places on a map, manage pet profiles, save favorites, make reservations, leave reviews, pay through PayPal and chat in real time. Establishments can manage their listings and reservations, while administrators can manage platform data.
Several developers worked on the product at the same time, so collaboration and integration were central parts of the project.
Problem
Pet owners need to find suitable places, confirm that they accept pets and interact with establishments through a reservation flow. Establishments need to present their services and manage incoming reservations.
The application therefore had to support multiple user roles and connected workflows. The team also needed to coordinate those workflows across different feature branches within a short deadline.
Solution
PetSpot uses separate application flows for pet owners, establishments and administrators. Pet owners can search for places through Google Maps, create pet profiles, save establishments, make reservations, pay, leave reviews and use real-time chat. Establishments can manage their listings and reservations, and administrators can manage platform data.
Key Features
- Multi-role authentication for pet owners and establishments.
- Pet profiles and favorites.
- Map-based discovery with Google Places search, autocomplete and geocoding.
- Reservation creation and management.
- Reviews and PayPal payments.
- Real-time chat using Socket.IO.
- Establishment listing and reservation management.
- Image management with Cloudinary.
- Administrative dashboard and data visualizations.
Technical Approach
PetSpot used a React frontend, Flask REST backend and PostgreSQL database. JWT handled authentication and authorization for the different user roles.
Google Maps and Google Places supported map rendering, place search, geocoding and autocomplete. PayPal handled payments, Socket.IO provided real-time chat, Cloudinary managed images and Flask-Admin supported administration.
The team divided work by feature. Each developer worked mainly in a separate Git branch and merged their changes into the shared codebase.
My Contributions
I contributed across both the frontend and backend. My work included:
- Designing and implementing the landing page.
- Contributing to the backend user flows.
- Working on authentication.
- Integrating Google Maps.
- Integrating Google Places.
- Implementing geocoding and place autocomplete flows.
- Integrating PayPal payments.
- Debugging application issues.
- Reviewing teammates’ code when time allowed.
- Helping integrate different parts of the application.
- Refactoring parts of the project to improve the separation between frontend and backend responsibilities.
This work gave me experience integrating third-party services and modifying code owned by other team members.
Engineering Decisions
Feature-based team ownership
The team divided work by feature so several developers could work in parallel. Each developer implemented an assigned area in a separate branch before integration. This supported speed but created coordination work when features shared code.
Multi-role application flows
Pet owners and establishments needed different authentication and application flows. The system had to define what each role could see and do in addition to handling authenticated and unauthenticated states.
Location-based discovery
Google Maps and Places supported the main discovery flow. Search, autocomplete, geocoding and map rendering had to work together to turn location data into usable search results.
External service integrations
PayPal, Cloudinary and Google APIs provided payments, image management and location features. Using these services expanded the product within the deadline but required coordinating several APIs and configurations.
Real-time communication
Socket.IO added real-time chat to an otherwise request-response application. The frontend and backend had to coordinate persistent events as well as standard API requests.
Challenges
The main challenges were collaboration, integration and time pressure. Git conflicts were common when features modified shared code, and the short deadline limited the time available for thorough review.
Integration and debugging were harder when contributors did not understand code owned by another feature branch. The team also had to balance learning new tools with delivering the project. AI assistance helped maintain speed, but the code still needed to be understood by the developer introducing it.
What I Learned
PetSpot taught me the importance of a shared source of truth, clear ownership and focused pull requests. A concise PR should explain what changed and why so teammates can review it without reconstructing the entire branch.
The project also showed me that communication often resolves cross-feature problems faster than working alone. AI can accelerate implementation under time pressure, but teammates still need to understand, maintain and integrate the code.
Future Improvements
If I approached PetSpot again, I would establish the team workflow and technical boundaries before increasing implementation speed. Improvements would include:
- Define a shared technical specification before development.
- Establish conventions for architecture and project structure.
- Keep pull requests small and focused, with clear descriptions.
- Review more changes before merging.
- Communicate earlier about features that affect shared code.
- Define ownership boundaries while preserving shared understanding.
- Reduce tightly coupled logic and clarify responsibilities.
- Add automated testing and improve technical documentation.
- Establish a clearer integration and review workflow.
- Avoid depending on code contributors cannot explain or maintain.
The project delivered broad functionality in a short time. In a future version, I would trade some feature breadth for stronger architecture, shared understanding and maintainability.