Case studies

Case study · Mobility platform

VrhamanArchitecture

Real-time bookings, multi-role apps, one coherent system.

Unified rentals across customer, vendor, and admin—with a production Socket.IO + MongoDB core and surfaces in Flutter, Next.js, and React.

Core stack

Socket.IOFlutterNext.jsMongoDBFirebaseAWS S3
Urban mobility context for Vrhaman
Hero visualReplace with product shots

01

Executive summary

Vrhaman is a full-stack mobility platform built to streamline vehicle rentals across customer booking, vendor fulfillment, and admin governance—transactional APIs, real-time coordination, and role-specific apps for speed, visibility, and reliability.

This narrative covers intent, architecture, engineering decisions, operations, and the path to portfolio-grade, enterprise-ready delivery.

02

Business problem

Traditional rental operations often fail at coordination and operational visibility:

  • Booking processes are slow and fragmented
  • Vendor response cycles are inconsistent
  • Customers lack transparent status visibility
  • Admin teams lack a single control plane for lifecycle performance
  • Payments, notifications, and operations sit in siloed tools

Vrhaman closes these gaps with one coordinated digital system.

03

Product vision

Vrhaman is designed to deliver:

  • Fast, predictable booking
  • Real-time customer ↔ vendor communication
  • Operational traceability for admins
  • Trust-building public web for acquisition
  • Scalable multi-city operations

04

System architecture

High-level map: multi-surface clients converge on a JWT-gated API and authenticated sockets, backed by MongoDB, Redis, Firebase, object storage, and payments.

Vrhaman platform architectureCustomer appFlutterVendor appFlutterAdminReact · ViteMarketingNext.jsAPI surfaceREST + WSExpress API + Socket.IOJWT · /api · realtime roomsMongoDBprimary dataRediscache / coordFirebasepush · authAWS S3mediaPaymentsPSPStateless API tier · role-scoped sockets · integration-ready services

Platform components

backend
Node.jsExpressTypeScriptMongoDBSocket.IO

Node.js, Express, TypeScript, MongoDB, Socket.IO

vrhaman-admin
ReactViteTypeScript

React + Vite admin dashboard

vrhaman-website
Next.jsReactTypeScript

Next.js marketing and conversion website

Vrhaman-Customer-Application
FlutterDartBLoC state managementHTTP client (Dio / REST)Socket.IOFirebase

Flutter customer app

vrhaman_vendor
FlutterDartBLoC state managementHTTP client (Dio / REST)Socket.IOFirebase

Flutter vendor app

Core architecture traits

  • JWT-protected API layer under `/api`
  • Authenticated Socket.IO handshake for real-time events
  • Role-specific application surfaces (customer, vendor, admin)
  • Service-oriented frontend API layers for maintainability
  • Integration-ready infra dependencies (S3, Firebase, Redis, payment stack)

Booking lifecycle flow

From discovery through settlement—event-driven handoffs.

Booking event flowDiscoverApp / webRequestBooking APIValidateRulesVendorSocket + pushDecisionAccept / rejectCustomerLive UISettlePaymentRequest → vendor action → persisted state → customer update

Real-time & notification lifecycle

Sockets, connection mapping, push, and reconnect sync.

Socket and notification lifecycleVendor clientSocket.IOConnection mapsocket_connectionsEvent bustyped status eventsFirebase FCMpush pathReconnectreplay latest bookingDeduped deliverysocket + pushDual-channel delivery · reconnect restores in-flight booking state

05

Core modules and capabilities

Surfaces inferred from backend routers/controllers—names follow repository conventions.

authusersvehiclesmake-modelvendor-vehiclebookingsearchpaymentnotificationreviewswishlistvendor-dashboardadmin/dashboardcouponsbankotplessimage-uploaddocument

06

User journey (end-to-end)

Eight-step lifecycle from discovery to admin oversight.

1/801

Customer discovers vehicles via app/web.

2/802

Customer submits booking request.

3/803

Backend validates request and triggers vendor-side event.

4/804

Vendor receives real-time booking notification.

5/805

Vendor accepts/rejects/updates status.

6/806

Backend persists state and pushes instant update to customer.

7/807

Payment and confirmation complete.

8/808

Admin panel provides full-lifecycle oversight and intervention capability.

07

Real-time booking engine

Token-authenticated sockets, role-aware channels, and reconnect-aware delivery are the product differentiator.

  • Token-authenticated socket sessions
  • Separate registration channels for customer and vendor sockets
  • Persistent socket-connection mapping (`socket_connections`)
  • Reconnect-aware state restoration (latest booking pushed on reconnect)
  • Status-specific event types (`accepted`, `rejected`, `cancelled`, `update`)
  • Timer-aware handling for payment confirmation windows

Business impact

  • Lower customer uncertainty
  • Faster vendor response loops
  • Better lifecycle transparency without manual polling

08

Engineering challenges solved

  • Reconnect-safe real-time synchronization for both user roles
  • Duplicate or stale socket registration avoidance
  • Token expiry handling in mobile app sessions
  • Cross-channel notification consistency (socket + push)
  • Time-sensitive booking transitions (e.g., payment confirmation windows)
  • Connectivity-aware UX fallback for unstable networks

09

Security and reliability

Implemented

  • JWT-based API authentication
  • Authenticated socket handshake
  • Role-aware route segregation
  • Token/session expiry handling in mobile flows

Recommended hardening

  • API rate limiting and abuse protection
  • Upload validation and secure media processing
  • Secret isolation policy across environments
  • Payment callback verification guardrails
  • Structured audit trails for admin-critical actions

10

Scalability strategy

  • Keep APIs stateless for horizontal scaling
  • Expand Redis strategy for caching/event coordination
  • Introduce queue-based async handling for notifications/heavy workflows
  • Add socket scaling strategy (adapter/pub-sub model)
  • Define index strategy for booking-heavy collections
  • Optimize media delivery with CDN-backed assets

11

Product decision rationale

Why separate customer and vendor apps?

  • Focused UX for distinct intents
  • Operational isolation and simpler workflows
  • Better notification targeting
  • Independent release cadence

Why Socket.IO over polling?

  • Lower interaction latency
  • Event-driven booking lifecycle UX
  • Less load at high booking activity
  • Cleaner status-sensitive workflows

12

Database design snapshot

  • Booking as the central transactional entity
  • User, vendor, and vehicle linked through booking relationships
  • Persistent socket session mapping for targeting
  • Support collections: coupons, wishlist, reviews, documents
  • Indexing: booking status/time, vendor/customer lookup, active lifecycle queries

13

DevOps and deployment view

Document per-environment behavior: dev, staging, prod, release and rollback, monitoring for API and socket health, CI/CD for backend and mobile builds, and infra anchors (compute, MongoDB host, Firebase, S3).

14

Contribution and ownership

Tune this list for interviews and portfolio accuracy.

Example ownership statements

  • Designed and structured backend route/module architecture
  • Implemented core real-time booking socket workflows
  • Built vendor/customer sync logic for booking status updates
  • Contributed to admin API structure and operational endpoints
  • Integrated platform-level services (Firebase messaging, payment flow hooks, media handling)

15

Tech stack

Same systems we ship in production—shown here as icon clusters (hover or focus for names).

Backend

REST APIs, auth, persistence, and Socket.IO coordination.

Node.jsExpressTypeScriptMongoDBSocket.IO

Admin dashboard

Operational console with fast local dev and typed UI.

ReactViteTypeScript

Marketing site

SEO-aware surfaces and conversion flows on the web.

Next.jsReactTypeScript

Mobile apps

Customer & vendor Flutter clients with realtime + push.

FlutterDartBLoC state managementHTTP client (Dio / REST)Socket.IOFirebase

Infra & payments

Object storage, cache, messaging, and checkout rails.

AWS S3RedisFirebaseStripe

16

Metrics and outcomes

Quantified outcomes matter most for investors and enterprise buyers—swap templates for live numbers.

Metrics to instrument

  • Daily and monthly bookings
  • Average vendor response time
  • Booking confirmation time
  • Socket event delivery latency
  • Payment success rate
  • Onboarding completion rate
  • Active vendors by city
  • Repeat customer rate
  • Cancellation rate reduction

Impact statement templates

  • Real-time event coordination reduced average booking confirmation delay from X min to Y sec.
  • Vendor response SLA compliance improved from A% to B%.
  • Customer cancellation due to delayed confirmation dropped by N%.

18

Customer feedback

Early validation themes from real riders.

The team is absolutely professional and the bikes are absolutely fantastic. Loved the service. Nice start-up, must recommend.

Abhay Tomar

7 April 2026

The app is really good. I rented a bike recently and the whole process was smooth, and the customer service is phenomenal. I really recommend this app if you want to book any vehicle.

Rohit Thakur

10 March 2026

Good onboarding makes users feel comfortable and helps them understand how the app works quickly.

Biswajit Swain

9 April 2026

Feedback themes

  • Service quality and professionalism
  • Smooth booking journey
  • Strong support perception
  • Clear onboarding

19

Roadmap

PHASE 1

Phase 1: Stabilization and foundation

  • Unified architecture and API contract documentation
  • Critical flow integration tests (auth, booking, payment, sockets)
  • Security baseline controls (rate limiting, secret policy, audit logs)

PHASE 2

Phase 2: Operational excellence

  • Observability stack (traces, error analytics, event metrics)
  • Admin analytics for conversion, cancellations, and vendor SLA
  • Reliability improvements for third-party service failures

PHASE 3

Phase 3: Scale and intelligence

  • Dynamic pricing engine
  • Event-driven booking pipeline
  • Demand forecasting and route intelligence
  • Vendor scoring and quality governance
  • Multi-city scaling playbook

20

Conclusion

Vrhaman is a coordinated platform—not a single app—with integrated customer, vendor, admin, and real-time layers. The foundation supports portfolio-grade storytelling once metrics and visuals land.

Next step

Ship at this engineering bar—with us.

Share your repo, metrics, or napkin sketch. We respond with a pragmatic plan.

Get in touch