We Built a Ride-Hailing Platform to Rival Uber and Ola — Before AI Made It Easy

Custom Calculated Fare Engine

Invoicing logic runs inside a background worker `BookingInvoice` after a ride has completed, avoiding any blockages in Web API transaction cycles.

# app/workers/booking_invoice.rb
split_details = {
  base_charge:      motor_model.base_fare,
  distance_fare:    [trip_km - motor_model.min_km, 0].max * motor_model.per_km_rate,
  time_fare:        trip_minutes * motor_model.per_minute_rate,
  additional_fare:  surge_applicable? ? motor_model.additional_fare : 0,
  discount:         calculate_promo_discount(passenger_offer, subtotal),
  tax:              (subtotal * region_tax.percentage / 100).round(2),
  wallet_deduction: [passenger.wallet_balance, net_payable].min,
  gross_amount:     subtotal,
  total_invoice:    (net_after_wallet).ceil   # ceiling round up to nearest rupee
}

Key features implemented here:

• Minimum distance threshold: Distance calculations only apply after subtracting baseline minimum distances.
• Predictable Surge: Surge charges are flat model overrides rather than floating multipliers, providing operations with absolute tariff controls.
• Wallet Safeguards: Capping deductions to `net_payable` ensures balances cannot drop below zero.

Geofenced Boundary Fare Tables

Cities are mapped into polygon-bounded sub-regions using geographic coordinates. Pricing configurations map to `(sub_region, motor_model)` tuples:

Zone (e.g., Chennai Hub)
  ├── Sub-Region A (Airport Geofence)
  │     ├── Compact: Base ₹70, ₹9/km
  │     └── Sedan:   Base ₹95, ₹12/km
  └── Sub-Region B (Central Station Geofence)
        ├── Compact: Base ₹50, ₹8/km
        └── Sedan:   Base ₹75, ₹11/km

When a pickup is requested, coordinates automatically map to a defined `RegionBound` polygon, fetching the correct tariff rules without dispatcher error.

Sidekiq Job Prioritization

24 background workers process asynchronous operational tasks. Prioritization rules prevent bulk batches from blocking active booking lifecycles.

# config/sidekiq.yml
:concurrency: 20   # production
:queues:
  - [critical, 10]        # Booking path (invoices, SMS dispatch, matching)
  - [default, 10]         # Reporting and general email queues
  - [product_detail, 2]   # Throttled bulk writes (Promo CSV imports, migrations)

Restricting `product_detail` queues to a weight of 2 prevents massive DB lockouts during marketing campaign distributions.

Bulk Campaign Distribution

Marketing teams frequently upload lists containing 50,000 passenger contacts for promotions. The importer handles writes asynchronously:

# Importer runs in background, updating file status
def perform(upload_id)
  upload = FileUploadStatus.find(upload_id)
  offers = []
  sms_jobs = []

  CSV.foreach(upload.file_path, headers: true) do |row|
    passenger = Passenger.find_by(phone: row['phone'])
    next unless passenger

    offers << {
      passenger_id:   passenger.id,
      discount_type:   upload.discount_type,
      discount_value:  upload.value,
      valid_to:        upload.expiry_date,
      created_at:      Time.current,
      updated_at:      Time.current
    }
    sms_jobs << [passenger.phone, "Promo code active!"]
  end

  # Perform bulk operations in database and queue
  if offers.any?
    PassengerOffer.collection.insert_many(offers)
    SendSms.perform_bulk(sms_jobs) # Previously push_bulk
  end

  upload.update(status: 'completed')
end

Consolidating writes into a single bulk insert (`insert_many`) and enqueuing Sidekiq jobs in bulk (`perform_bulk`, previously `push_bulk`) avoids high database locking overhead and CPU spikes under heavy load.

Shift Time-Slice Performance Analytics

To analyze fleet metrics, driver schedules are divided into precise operational windows:

TIME_SLICES = {
  morning:   ['08:30', '11:30'],
  afternoon: ['11:30', '12:30'],
  evening:   ['20:30', '23:30'],
  night:     ['23:30', '00:30']  # Spans midnight boundary
}

Batching filters queries in groups of 100 profiles, preventing system OOM (Out Of Memory) states when crunched on production nodes:

total_drivers = Driver.where(active: true).count
(1..(total_drivers / 100.0).ceil).each do |page|
  drivers_batch = Driver.where(active: true).skip((page - 1) * 100).limit(100)
  process_batch_analytics(drivers_batch)
end

India-Market Integrations

Custom verification and payment gateways implemented with low-level security:

• Aadhaar Biometric Bridge: OTP and fingerprint validation pipelines matching UIDAI government specifications.
• Freecharge & Paytm Hashing: Secure SHA256 checksum signatures implemented manually without heavy SDK dependencies.

# SHA256 checksum calculation for payment validation
checksum_string = [
  merchant_id,
  transaction_id,
  amount,
  currency,
  payment_mode,
  ENV['freecharge_secret_key']
].join('|')

checksum = Digest::SHA256.hexdigest(checksum_string)