Salon MVP Blueprint

Project Vision & Overview

Vision

To be the leading digital platform for discovering and booking beauty and wellness services across India, empowering both consumers and professionals.

Mission

To create a seamless, transparent, and trusted ecosystem connecting users with verified salons and stylists, simplifying bookings and payments through technology.

Solution

A mobile-first marketplace platform featuring location-based discovery, real-time availability, secure online payments, verified reviews, and robust tools for salon management.

Platform Fundamentals

Core business logic, goals, and financial model.

Core Goal

Unified ecosystem for discovery, bookings, payments.

Core Financial Logic

Platform Commission: 5%

Deducted from the final service price paid by user.

Payment Gateway Fees: ~2%

Platform business expense, absorbed into Platform Fee.

Revenue Model (Pilot → Future)

Source Pilot (1-6 Mo) Growth (6-18 Mo) Scale (18+ Mo)
Booking Commission 5-10% 7-12% 10-15%
Convenience Fee (User) ₹10-20 ₹20-30 ₹30-50
Verification / KYC Free ₹99 ₹199
Featured Listing None ₹499/mo ₹999+/mo
Salon Subscription None ₹499+/mo ₹999+/mo
Brand Product Tie-up None 10% cut 15-20%

Refined Financial Projection (Pilot Ahmedabad)

Based on: 100 Salons | 3 Bookings/Day/Salon | Avg Order Value (AOV) ₹500 | Commission 5% | Avg Convenience Fee ₹15 | Payment Gateway (PG) Cost 2% of (AOV + Fee) | Infra/Support Cost ₹1.2L/month.

Calculation Step Daily Value Monthly Value (x30 Days)
Total Daily Bookings 100 salons * 3 = 300 9,000
Gross Merchandise Value (GMV) 300 * ₹500 = ₹1,50,000 ₹45,00,000
(+) Platform Commission (5% of GMV) ₹1,50,000 * 0.05 = ₹7,500 ₹2,25,000
(+) Convenience Fees (₹15 x Bookings) 300 * ₹15 = ₹4,500 ₹1,35,000
A. Total Platform Revenue ₹7,500 + ₹4,500 = ₹12,000 ₹3,60,000
(-) Payment Gateway Fees (2% of User Payment) (₹500 + ₹15) * 0.02 * 300 = (~₹3,090) (~₹92,700)
(-) Estimated Infra/Support Costs ₹1,20,000 / 30 = (~₹4,000) (₹1,20,000)
B. Total Platform Costs (~₹7,090) (~₹2,12,700)
Estimated Net Profit (A - B) ~₹4,910 ~₹1,47,300

Revenue Model Evolution (Chart)

Detailed Feature Specifications

In-depth technical breakdown for each core MVP feature, accessed via the header dropdown.

Feature: User Registration

Allows a new customer to create an account using email/phone and password, granting the 'User' role.

Process: Guest fills form -> Backend validates -> Creates user doc -> Returns token.
Collections: users (Write)
Schema Vars: name, email, phoneNumber, passwordHash, roleId ('User'), createdAt, status ('Active')
API Endpoint: POST /api/auth/register
Data Flow: Input: name, email, phone, pass. Output: User obj, token.
Permissions: Guest only

Feature: User Login

Allows registered users to authenticate and receive an access token containing their permissions.

Process: User submits credentials -> Backend verifies -> Fetches User & Role -> Creates JWT with permissions -> Returns token.
Collections: users (Read), roles (Read)
Schema Vars: users: (email/phone, passwordHash, roleId). roles: (permissions).
API Endpoint: POST /api/auth/login
Data Flow: Input: email/phone, pass. Output: User obj (partial), JWT token (with permissions).
Permissions: Guest only

Feature: Salon Discovery & Search

Enables users to find salons via location (GPS/manual), filters (category, rating), and sorting.

Process: User searches/filters -> API queries DB -> Returns list of salons.
Collections: salons (Read)
Schema Vars: salonId, salonName, address (city, geolocation), avgRating, status ('Approved'), businessType.
API Endpoint: GET /api/public/salons
Data Flow: Input (Query Params): lat, lon, city, category, rating, sort. Output: Array of Salon summaries.
Permissions: Guest, User

Feature: Salon Detail Page

Displays comprehensive details about a specific salon.

Process: User clicks salon -> API fetches data -> Renders page.
Collections: salons (Read), services (Read), staff (Read), reviews (Read)
Schema Vars: All fields from `salons` doc. Lists of related services, staff, reviews.
API Endpoint: GET /api/public/salons/:salonId (+ maybe separate calls)
Data Flow: Input: salonId. Output: Full Salon object with nested/related data.
Permissions: Guest, User

Feature: Check Availability

Calculates and displays available time slots for a service on a given date.

Process: User selects date -> API fetches timings, blocked slots, service duration, existing bookings -> Calculates available slots -> Returns list.
Collections: salons (Read), services (Read), purchaseOrders (Read)
Schema Vars: salons: (timings, blockedSlots). services: (duration). purchaseOrders: (bookingDateTime, serviceSnapshot.duration).
API Endpoint: GET /api/public/availability
Data Flow: Input (Query Params): salonId, serviceId, date, staffId (opt). Output: Array of time strings.
Permissions: Guest, User

Feature: Create Booking & Payment

Handles the end-to-end booking process: creates temporary order, processes payment, confirms order.

Process: User confirms selection -> API creates orders doc -> Initiates Razorpay -> User pays -> Webhook confirms -> API updates orders, creates purchaseOrders, logs discount -> Returns confirmation.
Collections: orders (Write/Update), purchaseOrders (Write), discounts (Read/Update), giftCards (Read/Update), discountLogs (Write)
Schema Vars: All fields in orders & purchaseOrders. discounts: (code, currentUsage). giftCards: (code, currentBalance).
API Endpoint: POST /api/user/orders, POST /api/user/orders/:orderId/confirm (or webhook handler)
Data Flow: Input: serviceId, salonId, staffId, dateTime, codes. Output: Confirmation details.
Permissions: User (Permission: `CreateBooking`)

Feature: View Booking History

Allows logged-in users to see their past and upcoming confirmed bookings.

Process: User navigates to history -> API fetches relevant records -> Displays list.
Collections: purchaseOrders (Read)
Schema Vars: userId, salonId, serviceSnapshot, bookingDateTime, status.
API Endpoint: GET /api/user/bookings
Data Flow: Input: User token. Output: Array of Purchase Order objects.
Permissions: User (Permission: `ViewOwnBookingHistory`)

Feature: Gift Cards (MVP)

Allows users to purchase gift cards and redeem them during booking checkout.

Process (Buy): User selects amount -> Pays -> System generates code, creates giftCards doc.
Process (Redeem): User enters code at checkout -> API validates code & balance -> Applies credit to orders.priceBreakup -> Updates giftCards.currentBalance on confirmation.
Collections: giftCards (Write/Read/Update)
Schema Vars: code, initialAmount, currentBalance, status, expiryDate.
API Endpoint: POST /api/user/giftcards/buy (Purchase). Redemption logic inside POST /api/user/orders.
Data Flow: Input (Buy): Amount. Output: Gift card code. Input (Redeem): Code. Output: Updated price breakup.
Permissions: User (Permissions: `PurchaseGiftCard`, `RedeemGiftCard`)

Feature: Submit Review

Allows users to submit a rating and comment after a completed booking.

Process: User views completed booking -> Clicks "Leave Review" -> Submits form -> API creates `reviews` doc, updates `purchaseOrders.isReviewed`.
Collections: reviews (Write), purchaseOrders (Read/Update)
Schema Vars: reviews: (purchaseOrderId, userId, salonId, rating, comment, createdAt). purchaseOrders: (isReviewed).
API Endpoint: POST /api/user/reviews
Data Flow: Input: purchaseOrderId, rating, comment. Output: Confirmation.
Permissions: User (Permission: `CreateReview`)

Feature: Salon Registration

Initial application process for salon owners.

Process: User fills form -> Submits -> System creates salons doc (Pending) -> Triggers Razorpay onboarding -> Notifies Admin.
Collections: salons (Write), users (Update role?)
Schema Vars: salons: All fields, `status` ('Pending'). users`: `roleId`.
API Endpoint: POST /api/auth/salon/register
Data Flow: Input: Salon form data. Output: Confirmation.
Permissions: Authenticated User (not already SalonOwner)

Feature: Manage Salon Profile

Allows approved salon owners to update their salon details, timings, and amenities.

Process: Owner views profile -> Edits fields -> Saves -> API updates doc.
Collections: salons (Read/Update)
Schema Vars: salonName, contact, address, amenities.
API Endpoint: GET /api/salon/my-salon, PUT /api/salon/my-salon
Data Flow: Input (PUT): Updated fields. Output: Updated Salon object.
Permissions: SalonOwner (Permission: `UpdateOwnSalonDetails`)

Feature: Manage Timing & Holidays

Allows salon owners to set their weekly hours and add specific block-out periods (holidays, breaks).

Process: Owner uses calendar/form UI -> Saves changes -> API updates `salons` doc.
Collections: salons (Read/Update)
Schema Vars: timings, blockedSlots.
API Endpoint: PUT /api/salon/my-salon
Data Flow: Input: Updated timings object, array of blocked slots. Output: Updated Salon object.
Permissions: SalonOwner (Permission: `UpdateOwnSalonTimings`)

Feature: Manage Services

Salon owners add, edit, or delete services offered, including price, duration, staff assignment, and sale price.

Process: Owner uses dashboard UI -> API creates/updates/deletes service docs.
Collections: services (Write/Read/Update/Delete)
Schema Vars: salonId, name, description, category, duration, genderType, originalPrice, salePrice, addOns, assignedStaffIds, isActive.
API Endpoint: POST /api/salon/my-salon/services, PUT /api/salon/my-salon/services/:serviceId, DELETE /api/salon/my-salon/services/:serviceId
Data Flow: Input: Service data. Output: Confirmation/Updated Service.
Permissions: SalonOwner (Permission: `CreateEditDeleteOwnService`)

Feature: Manage Staff

Salon owners add, edit, or delete staff profiles and link them to services.

Process: Owner uses dashboard UI -> API creates/updates/deletes staff docs & updates relevant services.
Collections: staff (Write/Read/Update/Delete), services (Update assignedStaffIds)
Schema Vars: staff: (salonId, name, role, bio, imageUrl, experienceLevel, specializations). services`: (assignedStaffIds).
API Endpoint: POST /api/salon/my-salon/staff, PUT /api/salon/my-salon/staff/:staffId, DELETE /api/salon/my-salon/staff/:staffId
Data Flow: Input: Staff data. Output: Confirmation/Updated Staff.
Permissions: SalonOwner (Permission: `CreateEditDeleteOwnStaff`)

Feature: Manage Appointments

Salon owners view their upcoming/past bookings and update their status (e.g., mark as completed, cancel).

Process: Owner views booking list -> Clicks to update status -> API updates purchaseOrders doc.
Collections: purchaseOrders (Read/Update)
Schema Vars: salonId, bookingDateTime, status, userId, serviceSnapshot.
API Endpoint: GET /api/salon/my-salon/bookings, PUT /api/salon/my-salon/bookings/:purchaseOrderId/status
Data Flow: Input (PUT): purchaseOrderId, newStatus. Output (GET): Array of Purchase Orders.
Permissions: SalonOwner (Permission: `UpdateOwnBookingStatus`)

Feature: Manage Discounts (Salon)

Allows salon owners to create salon-funded promo codes and set sale prices on services.

Process (Promo): Owner fills form -> API creates `discounts` doc with `isPlatformFunded: false`.
Process (Sale): Owner edits service -> Sets `salePrice` -> API updates `services` doc.
Collections: discounts (Write/Read/Update), services (Update)
Schema Vars: discounts`: (salonId, code, type, value, valid...). `services`: (salePrice).
API Endpoint: POST /api/salon/my-salon/offers`, `PUT /api/salon/my-salon/services/:serviceId
Data Flow: Input: Discount/Service details. Output: Confirmation.
Permissions: SalonOwner` (Permissions: `CreateEditDeleteOwnDiscount`, `SetServiceSalePrice`)

Feature: Salon Dashboard

Provides salon owners with a basic overview of revenue, bookings, and top staff.

Process: Owner logs in -> API fetches aggregated data -> Displays widgets.
Collections: purchaseOrders (Aggregate), serviceAnalytics (Read)
Schema Vars: Aggregated counts and sums from purchaseOrders (revenue, bookings), grouped by staffSnapshot. Aggregated bookingCount from serviceAnalytics.
API Endpoint: GET /api/salon/my-salon/dashboard
Data Flow: Input: Salon token. Output: Dashboard statistics object.
Permissions: SalonOwner (Permission: `ViewBasicAnalytics`)

Feature: Manage Reviews (Salon)

Allows salon owners to view reviews for their salon and (in Phase 2) respond.

Process (MVP): Owner views reviews list -> API fetches relevant `reviews`.
Process (Phase 2): Owner clicks "Respond" -> Enters text -> API updates `reviews.salonResponse`.
Collections: reviews (Read/Update)
Schema Vars: salonId`, `rating`, `comment`, `createdAt`, `salonResponse`, `salonResponseAt`.
API Endpoint: GET /api/salon/my-salon/reviews`, `PUT /api/salon/my-salon/reviews/:reviewId` (Phase 2)
Data Flow: Input (PUT): reviewId, responseText. Output (GET): Array of Review objects.
Permissions: SalonOwner` (Permissions: `ViewOwnReviews`, `RespondToReviews` - Phase 2)

Feature: Admin Dashboard

Provides admins with a platform-wide overview of KPIs.

Process: Admin logs in -> API fetches aggregated data -> Displays widgets.
Collections: purchaseOrders (Aggregate), users (Count), salons (Count)
Schema Vars: Aggregated sums (finalPriceBreakup.total) and counts across collections.
API Endpoint: GET /api/admin/dashboard-stats
Data Flow: Input: Admin token. Output: Platform statistics object.
Permissions: Admin (Permission: `ViewPlatformDashboard`)

Feature: Salon Verification

Admin process to review KYC details and approve or reject new salon applications.

Process: Admin views pending list -> Selects salon -> Reviews details -> Clicks Approve/Reject -> API updates status.
Collections: salons (Read/Update)
Schema Vars: status`, `kycDetails`, `bankDetails`.
API Endpoint: GET /api/admin/salons (filter status='Pending'), POST /api/admin/salons/:salonId/approve, POST /api/admin/salons/:salonId/reject
Data Flow: Input: salonId. Output: Confirmation.
Permissions: Admin (Permission: `ApproveRejectSalon`)

Feature: Master User Management

Allows Admin to view all users and activate/deactivate their accounts.

Process: Admin views user list -> Clicks to change status -> API updates user doc.
Collections: users (Read/Update)
Schema Vars: userId, name, email, roleId, status.
API Endpoint: GET /api/admin/users, PUT /api/admin/users/:userId/status
Data Flow: Input (PUT): userId, newStatus. Output (GET): Array of User objects.
Permissions: Admin (Permission: `ActivateDeactivateUser`)

Feature: Master Booking Management

Allows Admin to view all bookings and initiate refunds.

Process: Admin views booking list -> Selects booking -> Clicks Refund -> API updates status and calls payment gateway API.
Collections: purchaseOrders (Read/Update)
Schema Vars: All fields in purchaseOrders.
API Endpoint: GET /api/admin/bookings, POST /api/admin/bookings/:purchaseOrderId/refund
Data Flow: Input (POST): purchaseOrderId, reason. Output (GET): Array of Purchase Orders.
Permissions: Admin (Permission: `ProcessRefunds`)

Feature: Platform Offer Management

Allows Admin to create platform-funded promotional codes.

Process: Admin fills offer form -> API creates discounts doc with specific flag.
Collections: discounts (Write)
Schema Vars: salonId (null), code, type, value, validFrom, validTo, totalUsageLimit, isPlatformFunded (true).
API Endpoint: POST /api/admin/offers
Data Flow: Input: Offer details. Output: Created Discount object.
Permissions: Admin (Permission: `CreatePlatformOffers`)

Feature: Platform Settings Management

Allows Admin to configure global platform rules like fees and categories.

Process: Admin accesses settings page -> Modifies values -> Saves -> API updates the single platformSettings doc.
Collections: platformSettings (Read/Update)
Schema Vars: platformFeePercent, convenienceFeeFixed, serviceCategories, activeCities, maxBookingDaysInAdvance.
API Endpoint: GET /api/admin/settings, PUT /api/admin/settings
Data Flow: Input (PUT): Updated settings object. Output: Updated settings object.
Permissions: Admin (Permission: `ManagePlatformSettings`)

Feature: Role & Permission Management

Allows SuperAdmin to define roles (like subscription tiers) and assign granular permissions.

Process: SuperAdmin uses UI -> API creates/updates docs in roles collection defining permission sets.
Collections: roles (Write/Read/Update)
Schema Vars: roleId, name, permissions` (object map).
API Endpoint: GET /api/admin/roles, POST /api/admin/roles, PUT /api/admin/roles/:roleId
Data Flow: Input: Role name and permissions object. Output: Confirmation/Role object.
Permissions: Admin` (Specific Permission: `CreateEditRole`, SuperAdmin only)

Feature: Abandoned Checkout Tracking

Allows Admin to view a list of booking attempts that were started but not completed.

Process: Admin views report -> API queries `orders` collection for relevant statuses.
Collections: orders (Read)
Schema Vars: userId`, `salonId`, `serviceId`, `createdAt`, `paymentStatus` (e.g., 1-Pending and older than TTL, or 4-Failed).
API Endpoint: GET /api/admin/abandoned-checkouts
Data Flow: Input: Admin token, optional filters. Output: Array of relevant order data.
Permissions: Admin (Permission: `ViewAbandonedCheckouts`)

Design Guidance & Wireframes

Mobile-first principles and wireframe descriptions for key screens.

Mobile-First Principles

  • **Layout:** Single-column layout. Vertical stacking. Bottom tabs or hamburger menu.
  • **Touch Targets:** Min 44x44px, adequate spacing.
  • **Typography:** Legible base size (~16px).
  • **Forms:** Multi-step for complexity. Native mobile inputs.
  • **Images:** Optimize for mobile.
  • **Interactions:** Simple tap/swipe. Avoid complex hover.
  • **Performance:** Minimize JS bundles, optimize assets.

Wireframe Descriptions (Mobile View)

Screen 1: Homepage (Guest View)

Top Bar: Logo | Location Selector

Hero...

Search

Categories

...

Featured Near You

...(Cards)...
Home...

**Description:** ...

Screen 2: Salon Detail Page

Top Bar: ← Back | Salon Name | ♡ Like
Image Placeholder

Modern Cuts ★★★★☆ ...

...
...

Hair

... ₹500 ₹400 Book
...
Home...

**Description:** ...

Screen 3: Booking - Select Date & Time

Top Bar: ← Back | Select Date & Time

Select Date

Calendar

Select Time

...
Next
Home...

**Description:** ...

Interactive Financial Modeler

Adjust the inputs to see how different scenarios affect the price breakup for the user and the final payout for the salon.

Scenario Builder

User's Price Breakup

Salon's Payout

Core Logic & Visual Flows

Visual flowcharts for key processes and the definitive discount rules.

User Booking Process (Visual Flow)

Start
Search/Select Salon & Service
Select Date & Time
Select Staff (Optional)
Create `orders` (Pending)
Show Summary
Apply Discount/Gift Card (Optional)
Validate Code / Update Price
Proceed to Payment
Redirect to Razorpay
Complete Payment
Payment Success?
Yes ↓
Webhook Received
Update `orders` (Completed)
Create `purchaseOrders`
Update Logs
Send Notification
End (Confirmed)
No ↓
Webhook Received or Timeout
Update `orders` (Failed)
End (Failed)

Salon Onboarding Process (Visual Flow)

Start (Homepage)
Click "List Your Salon"
Show Registration Form
Fill Details (Salon, KYC, Bank) & Submit
Create `salons` doc (Pending)
Trigger Razorpay API
Redirect Owner to Razorpay
Complete Verification on Razorpay
Receive Razorpay Webhook
Update `salons` (RP ID)
Notify Admin
Admin Verifies (See Below)
If Approved: Update `salons` (Approved)
Notify Owner
End (Salon Live or Rejected)

Admin Salon Verification (Visual Flow)

Start (Admin Dashboard)
Navigate to Verification Queue
Display Pending Salons
Select a Salon
Display Details & KYC Docs
Review Information
Approve?
Yes ↓
Call `POST /approve`
Update `salons` (Approved)
Notify Owner
No ↓
Call `POST /reject`
Update `salons` (Rejected)
Notify Owner
↓ (Join)
End (Verification Complete)

Gift Card Purchase & Redemption

Purchase Flow

Start (User selects Gift Card)
Select Amount
Proceed to Payment
Redirect to Razorpay
Complete Payment
Webhook Received -> Verify -> Generate Code -> Create `giftCards` doc ('Active')
End (Code Displayed/Sent)

Redemption Flow (During Booking)

Start (Booking Summary Page)
Enter Gift Card Code
API Validates Code & Balance (Reads `giftCards`)
Valid & Balance > 0?
Yes ↓
Apply Credit to `orders.priceBreakup`
Update Summary UI
No ↓
Show Error Message
↓ (Join)
End (User Proceeds)

(Note: `giftCards.currentBalance` updated upon *successful purchase order* creation)

Razorpay Integration Note:

Gift Card purchases are standard Razorpay checkouts. For redemption, the platform validates the code *before* initiating the final Razorpay payment for the booking, passing the potentially reduced amount to Razorpay.

Platform Rulebook: Discounts

Type A: "Sale Price"

Direct price reduction set by salon on a service (`services.salePrice`). Displayed as ₹500 ₹400.

Type B: "Promo Code"

Code created by salon (`discounts` doc, `isPlatformFunded: false`). Applied at checkout.

Type C: "Platform Offer"

Code created by Admin (`discounts` doc, `isPlatformFunded: true`). Platform bears cost.

Payment Gateway Integration (Razorpay)

Detailed flow for onboarding salons and handling payment splits.

1. Salon Onboarding (Razorpay Sub-merchant)

Links salon's bank account via Razorpay for automatic settlements.

Start (Salon submits registration)
Backend: Creates `salons` ('Pending')
Backend: Calls Razorpay Partner API (Pre-fills Sub-merchant)
Razorpay: Creates Sub-merchant, Returns ID
Backend: Stores ID in `salons.razorpayLinkedAccountId`
Backend: Generates Razorpay Onboarding Link
Redirect Owner to Razorpay Hosted Onboarding
Owner: Verifies details & Uploads docs on Razorpay
Razorpay: Verifies documents
Razorpay: Sends Webhook (`account.updated`)
Backend: Updates `salons` (`razorpayStatus`), Notifies Admin
End (Eligible for payouts after Admin approval)

2. Payment Split Logic (Razorpay Route)

How money flows from user to platform and salon.

Start (User Clicks Pay)
Backend: Creates Razorpay Order
User Completes Payment
Razorpay: Captures funds to Platform Nodal Account
Razorpay: Sends Webhook (`payment.captured`)
Backend: Verifies -> Updates `orders` -> Creates `purchaseOrders`
Backend: Calls Razorpay Route API (`/transfers`) specifying split amounts (To Salon ID, Retain Commission)
Razorpay Route: Executes internal transfers
Razorpay: Performs auto-settlement (T+2/T+3)
End (Funds split & scheduled)

Key Considerations:

  • Requires Razorpay Route activation & Nodal Account.
  • Backend calculates and initiates splits via Transfer API.
  • Settlement timing managed by Razorpay.

Permissions & Access Control

The granular list of permissions defining platform access.

Permission Access Control List

This list defines actions. Specific roles (defined in the `roles` collection) will be assigned `true`/`false` or limits for relevant permission keys.

  • AccessAdminPanel
    • ViewPlatformDashboard
    • ManagePlatformSettings (SuperAdmin Only)
      • UpdateFeesAndCommission
      • UpdateServiceCategories
      • UpdateActiveCities
      • UpdateSystemConfigs
    • ManageSalons
      • ViewAllSalons
      • VerifyPendingSalons
      • ApproveRejectSalon
      • EditAnySalonProfile
      • ActivateDeactivateSalon
    • ManageUsers
      • ViewAllUsers
      • EditAnyUserProfile
      • ActivateDeactivateUser
    • ManageBookings
      • ViewAllBookings
      • CancelAnyBooking
      • ProcessRefunds
    • ManageDiscounts
      • ViewAllDiscounts
      • CreatePlatformOffers
      • DeactivateAnyDiscount
    • ManageGiftCards
      • ViewAllGiftCards
      • IssueManualGiftCard
    • ManageReviews
      • ViewAllReviews
      • DeleteReview
    • ViewAnalytics
      • ViewAbandonedCheckouts
      • ViewDiscountLogs
      • ViewServiceAnalytics
    • ManageRoles (SuperAdmin Only)
      • CreateEditRole
    • ManageContent (Future)
      • UpdateHomepageContent
      • ManageBlogPosts

Technical Blueprint

The complete technical specification: API reference and final database schema.

API Endpoint Definitions (Phase 1)

POST /api/auth/register          (User registration)
POST /api/auth/login             (User login)
POST /api/auth/salon/register    (Salon owner initial application)

Database Schema Details (Final 13 Collections)

Document-style schema for each collection.

AI Integration

Planned features using the API to add intelligence and value to the platform.

For Salons

AI Service Descriptions

"Generate with AI" button for professional service descriptions.

For Salons

Smart Review Replies

AI suggests courteous replies to customer reviews.

For Admins

AI Review Summarizer

AI summarizes review themes for quick quality assessment.

Future AI Features

AI Booking Assistant

Chatbot for natural language booking queries.

Style Recommender (Vision API)

Suggest salons based on uploaded hairstyle photos.

Development Costs & Alternatives (MVP)

Structured breakdown of potential costs and savings.

A. Estimated Required Costs (Monthly, Initial Scale)

1. Hosting (Next.js + NestJS)

Cloud VM/Containers (e.g., 2 small instances) + CDN

~ ₹1,500 - ₹5,000

2. Database (MongoDB Atlas)

M0 Free Tier (if low usage) or M10/M20 Shared Tier

₹0 - ₹4,000

3. Payment Gateway (Razorpay)

Charged per transaction

~2% + GST / Transaction

4. Domain Name

Annual Cost (pro-rated monthly)

~ ₹100

5. SMS Notifications

Estimate based on booking volume (e.g., 9000 bookings * 2 SMS each @ ₹0.20)

~ ₹3,600

Estimated Initial Monthly Infrastructure Cost: ~ ₹5,200 - ₹13,700+

B. Cost-Saving Strategies (MVP Focus)

1. Maximize Free Tiers

• Use Vercel Hobby for Frontend.

• Use Cloud Run/AWS Lambda free quota for Backend APIs if possible (check cold starts).

• Stay on MongoDB Atlas M0 as long as feasible.

• Use SendGrid/Mailgun free tiers for email.

2. Optimize Notifications

• Rely heavily on Email and In-App notifications (free).

• Use SMS *only* for absolutely critical alerts (e.g., booking confirmation).

• Delay WhatsApp integration.

3. Use Open Source / Free Maps

• Leaflet.js + OpenStreetMap for basic map display.

• Use free geocoding tiers carefully (Nominatim).

4. Defer Non-Essentials

• Postpone advanced analytics visualizations that might require heavier DB queries.

• Delay integration with third-party marketing tools.

Notification Strategy

Details on how, when, and where notifications will be used.

Channels:

  • **Email (MVP):** Primary channel (SendGrid, Mailgun, AWS SES).
  • **SMS (MVP):** For critical alerts (Twilio, Vonage, MSG91).
  • **In-App Notifications (MVP):** Simple dashboard alerts.
  • **Push Notifications (Future Phase):** For mobile app.
  • **WhatsApp (Future Phase):** Richer comms (Business API).

Key Trigger Points (MVP):

  • **User:** Booking Confirm/Remind/Cancel/Refund (Email, SMS).
  • **Salon Owner:** New Booking, User Cancel, Appointment Reminder, Payout Summary (Email, In-App).
  • **Admin:** New Salon Pending, System Alert (Email, In-App).

Cost Considerations:

Utilize email free tiers. SMS: ~₹0.15 - ₹0.50/message. WhatsApp API: Higher cost. Prioritize Email/In-App, use SMS judiciously for MVP.

Multi-Phase Future Roadmap

The finalized plan for platform evolution post-MVP.

Phase 1: Core MVP

  • Salon Profile & KYC
  • Basic Service/Staff Mgt
  • Timing & Holiday Mgt
  • Appointment Mgt (Accept/Reject)
  • Basic Salon Dashboard
  • User Discovery & Search
  • Detailed Salon Pages
  • Booking & Payment Flow
  • User Profile & History
  • Gift Cards (Purchase/Redeem)
  • Admin Verification
  • Admin Booking Oversight
  • Admin Platform Settings
  • Abandoned Checkout Tracking
  • Basic Notifications (Email/SMS)

Phase 2: Monetization & Growth

  • Salon Subscription Plans
  • Self-Serve Discounts
  • Advanced Analytics Pro
  • Salon Review Responses
  • User Wallet & Loyalty
  • Admin Subscription Mgt
  • Featured Listings
  • **Blog/News Section (Content Marketing)**

Phase 3: Scaling & Expansion

  • Advanced Staff Mgt (Pricing, Schedules)
  • Home Service Module
  • Push & WhatsApp Notifications
  • Brand/Product Integration
  • Dynamic Peak Hour Pricing
  • Automated Payouts
  • **Trending Services/Styles Section**

Project Summary: Cost & Timeline

High-level estimates for MVP development.

Estimated MVP Infrastructure Costs

A. Initial Phase (Low Traffic / Utilizing Free Tiers)

• Hosting (Vercel/Cloud Free Tier): ₹0

• Database (MongoDB Atlas M0): ₹0

• Email (SendGrid Free Tier): ₹0

• SMS (Low Volume Estimate): ~₹500 - ₹1,000 / month

• Domain: ~₹100 / month

Total Estimate A: ~ ₹600 - ₹1,100 / month

B. Scaling Phase (Moderate Traffic / Paid Tiers)

• Hosting (Scaled Cloud Instances): ₹3,000 - ₹8,000 / month

• Database (Atlas M10/M20): ₹4,000 - ₹6,000 / month

• SMS (Increased Volume): ₹3,000 - ₹5,000 / month

• Caching/Queuing (Optional): ₹1,000 - ₹2,000 / month

• Domain: ~₹100 / month

Total Estimate B: ~ ₹11,100 - ₹21,100+ / month

Note: Excludes variable payment gateway transaction fees (~2%).

Estimated MVP Development Timeline

Based on a team of ~4-5 (Frontend, Backend, QA, Design/PM):

Step 1: Design & Prototyping

UI/UX Design based on wireframes, final design system.

~ 2-4 Weeks

Step 2: Backend Core Development

Setup project, Auth, DB models, Core APIs (Salons, Services, Users).

~ 4-6 Weeks

Step 3: Frontend Core Development

Setup project, UI components, Public pages (Home, Search, Detail), Auth flow.

~ 4-6 Weeks

Step 4: Booking & Payment Integration

Booking flow (Frontend + Backend), Razorpay, Order logic, Notifications.

~ 3-4 Weeks

Step 5: Salon & Admin Dashboards

Implement management features for Salon Owners and Admins.

~ 4-5 Weeks

Step 6: Testing, QA & Bug Fixing

End-to-end testing, performance checks, refinement.

~ 2-4 Weeks

Total Estimated MVP Build: ~ 4.5 - 6.5 Months

Note: Assumes parallel workstreams for frontend/backend after core setup. Can vary significantly.