This project was originally developed and maintained in another GitHub account. It has been mirrored here as part of my professional portfolio to showcase my work and development experience.

A Django-based local barbershop discovery platform for customers and shop owners in Masbate, Philippines.

Masbate Barbers is a full-stack web application that helps customers find local barbershops and helps barbershop owners manage their public business profiles.

The platform works as a local directory and lightweight shop management system. Customers can search for shops, compare services, view photos, check contact details, and review owner-managed availability. Shop owners can register, log in, create shop profiles, publish business details, manage services, upload images, set opening hours, and maintain basic availability status.

This MVP is focused on discovery and profile management. It is not yet a full appointment booking or payment platform.

Many local barbershops rely on word of mouth, Facebook pages, or incomplete online listings. Customers often need to manually ask around to find shop locations, services, prices, opening hours, or whether a barber is currently available.

Masbate Barbers solves this by giving customers one place to discover and compare local barbershops, while giving shop owners a simple self-service dashboard to keep their business information updated.

• Public landing page with featured published barbershops
• Searchable shop directory
• Search by shop name, description, address, and service name
• Barangay filtering for local discovery
• Pagination for shop listing results
• Verified and featured shop ranking logic
• Public shop profile pages with cover photo, description, services, gallery, address, contact details, and opening hours
• Public availability display with owner-managed status such as available, currently cutting, on break, offline, and closed
• Date and time availability checking against manual shop time slots
• Owner registration, login, logout, and owner-only dashboard
• Shop profile create and edit workflow
• Draft and published shop visibility states
• Service management with name, description, price, duration, and active status
• Shop photo uploads with captions, sort order, and cover candidate marking
• Opening hours management by day
• Manual time slot management with available, booked, and blocked states
• Django admin support for users, shops, services, images, hours, availability, and time slots
• SEO-focused templates with metadata, canonical URLs, Open Graph tags, structured data, robots.txt, and sitemap.xml
• Browser-side image preview and compression before upload

Landing page	Shop directory

Owner login	Shop profile setup

Owner dashboard	Mobile shop setup

I designed and developed the project, including the Django backend logic, database models, owner authentication flow, public discovery pages, dashboard workflows, frontend templates, static assets, media handling, SEO configuration, and deployment preparation.

• Full-stack Django web development
• Database modeling with relationships, constraints, indexes, and custom user roles
• Authentication and role-based access control
• CRUD workflows for shop profiles, services, photos, opening hours, and availability
• Server-rendered frontend development with reusable templates
• Form validation, CSRF-protected POST actions, and protected owner routes
• Static and media file handling
• Search, filtering, pagination, and query optimization with select_related and prefetch_related
• Django admin customization
• SEO implementation for public-facing pages
• Responsive interface development
• Browser-side image optimization before upload
• MVP-focused product architecture for a local marketplace-style platform

Customer flow:

User visits landing page
->
Searches or browses barbershops
->
Filters by keyword or barangay
->
Views shop profile
->
Checks services, photos, hours, contact details, and availability
->
Calls or messages the shop directly

Owner flow:

Owner creates an account
->
Logs into owner dashboard
->
Creates or edits shop profile
->
Adds services, photos, opening hours, and availability slots
->
Publishes the shop profile
->
Customers can discover the published shop publicly

Main data models:

• User - custom Django user with customer and owner roles
• Barbershop - shop profile, location, contact details, publishing status, verification, and featured ranking
• Service - shop services with price, duration, and active status
• ShopImage - gallery images with captions and ordering
• OpeningHour - weekly shop operating hours
• ShopAvailabilityStatus - current owner-managed shop status
• ShopTimeSlot - manual dated availability slots

barbers/
|-- backend/                 # Owner dashboard, models, forms, admin, and protected shop management views
|-- barbers/                 # Django project settings, root URLs, WSGI, and ASGI configuration
|-- frontend/                # Public-facing views and URLs
|-- media/                   # Uploaded media files for local development
|-- static/                  # CSS, JavaScript, images, icons, and manifest files
|-- staticfiles/             # Collected static files for deployment
|-- templates/               # Shared, frontend, and backend Django templates
|-- manage.py                # Django management entry point
|-- requirements.txt         # Python dependencies
`-- README.md                # Project documentation

1. Clone the repository:

git clone https://github.com/astigPree/barbers.git
cd barbers

2. Create and activate a virtual environment:

python -m venv venv

Windows:

venv\Scripts\activate

macOS/Linux:

source venv/bin/activate

3. Install dependencies:

pip install -r requirements.txt

4. Configure local settings.

The current project stores Django settings directly in barbers/settings.py. For local development, confirm these values are safe for your machine:

• SECRET_KEY
• DEBUG
• ALLOWED_HOSTS
• SITE_URL
• DATABASES

For a public or production-ready version, move sensitive settings to environment variables.

5. Create database migrations if they are not included in your clone:

python manage.py makemigrations

6. Apply database migrations:

python manage.py migrate

7. Create an admin user:

python manage.py createsuperuser

8. Collect static files when running with production-style static configuration:

python manage.py collectstatic

9. Start the development server:

python manage.py runserver

10. Open the project in your browser:

http://127.0.0.1:8000/

Useful local URLs:

Public homepage:       http://127.0.0.1:8000/
Shop directory:        http://127.0.0.1:8000/shops/
Owner registration:    http://127.0.0.1:8000/owners/register/
Owner login:           http://127.0.0.1:8000/owners/login/
Admin panel:           http://127.0.0.1:8000/admin/

No .env.example file is currently included. A safe environment example for a production-ready version would look like this:

DJANGO_SECRET_KEY=replace-with-a-secure-secret-key
DJANGO_DEBUG=True
DJANGO_ALLOWED_HOSTS=localhost,127.0.0.1
DJANGO_SITE_URL=http://127.0.0.1:8000

If these variables are added, barbers/settings.py should be updated to read from the environment instead of storing sensitive values directly in code.

After setup, customers can browse the public shop directory, search for barbershops, filter by barangay, and open individual shop profiles.

Shop owners can register an owner account, log in to the dashboard, create a shop profile, publish it, and manage business details such as services, photos, opening hours, and availability. Platform admins can use Django Admin to review users and shops, mark shops as verified or featured, and manage platform data.

• Move sensitive settings such as SECRET_KEY, DEBUG, allowed hosts, and site URL into environment variables
• Add a committed .env.example file for safer onboarding
• Add automated tests for models, views, forms, permissions, and core workflows
• Add a real booking/reservation flow for customers
• Add queue management for walk-in customers
• Add multi-barber support per shop
• Add email or SMS notifications for reservations and availability updates
• Add subscription billing or paid featured placement for monetization
• Add analytics for shop profile views, search demand, and conversion actions
• Add production database support such as PostgreSQL
• Improve deployment documentation for a production server
• Add screenshots or a short demo video for portfolio presentation

This project strengthened my practical experience in building a local marketplace-style Django application from MVP planning to implementation. I worked through custom user roles, owner-only workflows, database relationships, media uploads, public search and filtering, SEO-friendly page structure, admin tooling, and deployment-ready static file handling.

The project also reinforced the importance of building business value first: helping customers make faster decisions while giving local shop owners a simple system they can realistically maintain.

Ericson Mark Abayon Guanzon
GitHub: https://github.com/astigPree
Portfolio: https://programmerin.masbate.top
Email: maxcrizguanzon123@gmail.com "# babers"