Forem: Rachit Avasthi

How Platforms Like Zomato, Swiggy, Uber, and Ola Update Rider’s Location in Real Time

Rachit Avasthi — Fri, 13 Mar 2026 08:11:05 +0000

When you order food on Zomato or Swiggy, or book a ride on Uber or Ola, you can see the rider or driver moving live on a map.

This real‑time tracking feels simple on the surface—but behind it lies a well‑orchestrated system of GPS, mobile apps, backend servers, and real‑time communication protocols.

In this blog, we’ll break down how these platforms update a rider’s location in real time, step by step, in a way that’s easy to understand—even if you’re not deeply technical.

1. The Core Building Block: GPS on the Rider’s Phone

Everything starts with the rider’s smartphone.

How GPS Works

The rider’s phone constantly communicates with GPS satellites
These satellites help calculate:
- Latitude
- Longitude
- Speed
- Direction

Accuracy Factors

GPS accuracy depends on:

Open sky vs crowded buildings
Network quality
Device sensors (accelerometer, gyroscope)

📍 Typically, accuracy ranges between 5–20 meters, which is good enough for real‑time tracking.

2. Rider App Continuously Captures Location

The delivery or driver app (Zomato Delivery App, Uber Driver App, etc.) runs a background location service.

What the App Does

Fetches GPS coordinates every:
- 2–5 seconds (Uber/Ola)
- 5–10 seconds (Zomato/Swiggy)
Adjusts frequency based on:
- Movement speed
- Battery level
- Ride/order state

Smart Optimization

To save battery:

Location updates slow down when idle
Updates increase when the rider is moving

3. Sending Location to Backend Servers

Once the app captures the location, it must send it to the platform’s servers.

How Data Is Sent

The app sends:

{
  riderId,
  latitude,
  longitude,
  timestamp,
  speed,
  heading
}

Using:

HTTPS (REST APIs) for periodic updates
WebSockets / gRPC / MQTT for real‑time streaming

✅ Secure

✅ Low latency

✅ Scalable

4. Real‑Time Communication: The Secret Sauce

Polling the server every second would be slow and expensive.

Instead, platforms use real‑time messaging systems.

Common Technologies Used

WebSockets
Firebase Realtime Database
Kafka + WebSocket Gateway
AWS AppSync / Google Pub‑Sub

Why Real‑Time Tech Matters

Server pushes updates instantly
No repeated API calls
Smooth map movement on the customer’s screen

5. Backend Systems Process Location Updates

The backend doesn’t just forward location—it processes and optimizes it.

Backend Responsibilities

Validate rider authenticity
Smooth noisy GPS signals
Snap location to roads (Map Matching)
Detect anomalies (GPS jumps)

Map Matching Example

If GPS says the rider is:

“10 meters inside a building”

Backend adjusts it to:

“Nearest road on Google Maps”

This makes movement look natural and realistic.

6. Customer App Receives Live Updates

Now comes the magic users actually see.

Customer App Flow

Customer opens order/ride screen
App subscribes to rider’s location channel
Backend pushes live coordinates
Map updates smoothly every few seconds

Smooth Animations

Instead of jumping points:

Apps interpolate movement
Animate markers
Predict next position using speed & direction

This creates the illusion of continuous motion.

7. Maps Integration (Google Maps / Mapbox)

These platforms don’t build maps from scratch.

Maps Providers

Google Maps
Mapbox
OpenStreetMap (with custom layers)

What Maps APIs Do

Render roads and buildings
Calculate ETA
Suggest shortest routes
Handle traffic data

📍 Real‑time traffic also helps recalculate ETA dynamically.

8. Handling Network & GPS Failures

Real‑world conditions are messy.

Common Problems

Poor internet
GPS signal loss
Phone battery saver mode

How Apps Handle This

Cache last known location
Predict movement temporarily
Display “Updating location…” messages
Fall back to lower‑frequency updates

This ensures the experience doesn’t completely break.

9. Security & Privacy Considerations

Tracking users is sensitive, so strict rules apply.

Privacy Safeguards

Location tracking only during active orders/rides
Data encrypted in transit
Automatic tracking stop after completion
Compliance with GDPR & local laws

🚫 Riders are not tracked 24/7

10. High‑Level Architecture Summary

Rider Phone
   ↓ (GPS)
Rider App
   ↓ (WebSocket / API)
Backend Servers
   ↓ (Real-time Push)
Customer App
   ↓
Live Map View

Simple to look at, but highly optimized at scale.

Why This Matters at Scale

Platforms like Uber or Swiggy handle:

Millions of location updates per second
Low latency requirements
Global scale traffic

Even a 1‑second delay can:

Increase customer anxiety
Cause missed pickups
Affect trust

That’s why this system is engineered with precision.

Final Thoughts

Real‑time rider tracking is a perfect blend of mobile sensors, networking, backend engineering, and UX design.

What looks like a small moving dot on your screen is actually:

GPS satellites
Background services
Real‑time streaming
Distributed systems
Map intelligence

All working together—seamlessly.

Fixing PySpark “Cannot run program python3” Error on Windows

Rachit Avasthi — Fri, 19 Dec 2025 04:56:25 +0000

When running PySpark on Windows, many beginners (and even experienced developers) encounter the following error:

java.io.IOException: Cannot run program "python3":
CreateProcess error=2, The system cannot find the file specified

This article explains why this error happens, why one solution works and another doesn’t, and the correct, professional way to fix it permanently.

Understanding the Problem

Apache Spark is written in Java/Scala, but PySpark allows us to write Spark applications in Python.

When Spark executes Python code, it:

Starts the JVM (Java Virtual Machine)
Spawns a Python worker process
Communicates between Java and Python using Py4J

By default, Spark tries to launch a Python executable named:

python3

This works on Linux and macOS, but on Windows, the Python executable is:

python.exe

Since python3 does not exist on Windows, Spark fails to start the Python worker and the job crashes.

Why Setting Python Inside the Code Works

A common workaround is setting the Python executable directly in the script:

import os

os.environ["PYSPARK_PYTHON"] = r"C:\Users\User\Desktop\Training\Week5\venv\Scripts\python.exe"
os.environ["PYSPARK_DRIVER_PYTHON"] = r"C:\Users\User\Desktop\Training\Week5\venv\Scripts\python.exe"

from pyspark.sql import SparkSession

This works because:

The environment variables are set before SparkSession is created
Spark reads these variables immediately
The correct Python interpreter is used

However, this approach is not ideal:

The same code must be repeated in every PySpark file
Scripts become cluttered
It is not how Spark is configured in real-world projects

Why the PowerShell Method Often Fails

You may try setting environment variables in PowerShell:

$env:PYSPARK_PYTHON="C:\path\to\python.exe"
$env:PYSPARK_DRIVER_PYTHON="C:\path\to\python.exe"
python Lab1.py

This sometimes fails because:

PowerShell variables are session-scoped
Closing the terminal clears them
Running Spark from another terminal or editor loses them
Spark must see these variables before the JVM starts

This makes the approach unreliable for long-term use.

The Correct and Permanent Solution (Best Practice)

The recommended and professional solution is to set these variables at the Windows system level.

This ensures:

Spark always knows which Python to use
No code changes are required
Works across all projects and terminals

Step-by-Step: Setting Environment Variables on Windows

Step 1: Open Environment Variables

Press Windows + R
Type:
```
sysdm.cpl
```
Go to the Advanced tab
Click Environment Variables

Step 2: Add User Environment Variables

Under User variables, click New and add the following:

Variable 1

Name: PYSPARK_PYTHON

Value:

C:\Users\User\Desktop\Training\Week5\venv\Scripts\python.exe

Variable 2

Name: PYSPARK_DRIVER_PYTHON

Value:

C:\Users\User\Desktop\Training\Week5\venv\Scripts\python.exe

Click OK on all windows.

Step 3: Restart Your Terminal (Very Important)

Environment variables only load when a terminal starts.

Close all PowerShell / CMD / VS Code terminals
Open a new PowerShell
Activate your virtual environment:
```
.\venv\Scripts\activate
```

Step 4: Verify the Setup

Run:

echo $env:PYSPARK_PYTHON

If you see your Python path, Spark will see it too.

Clean PySpark Code (After Fix)

Once the environment is set, your PySpark script stays clean:

from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

data = [
    (1, "Laptop", "Electronics", 50000),
    (12, "Mobile", "Electronics", 20000),
    (3, "Tablet", "Electronics", 15000),
    (4, "Headphones", "Accessories", 3000),
    (5, "Keyboard", "Accessories", 2500)
]

df = spark.createDataFrame(
    data, ["id", "product", "category", "amount"]
)

df.show()

No environment setup code is required anymore.

Key Takeaways

Spark defaults to python3, which breaks on Windows
Setting Python inside the script works but is not scalable
PowerShell environment variables are temporary
Windows Environment Variables are the correct solution
Always configure Spark outside your code

Final Thought

If you are learning Spark on Windows, this configuration step is mandatory.

Once set correctly, PySpark becomes stable, predictable, and production-ready.

Happy Spark learning 🚀

Fixing PySpark on Windows: Downgrading from Python 3.13 to 3.11 (Complete Guide)

Rachit Avasthi — Fri, 19 Dec 2025 04:55:11 +0000

If you’re trying to run PySpark on Windows with Python 3.13, you’ll quickly run into errors like:

AttributeError: module 'socketserver' has no attribute 'UnixStreamServer'

This can be frustrating—especially when your code is perfectly fine.

In this post, I’ll walk you through a complete, working setup for PySpark on Windows by:

Installing Python 3.11 alongside Python 3.13
Creating a clean virtual environment
Installing a compatible PySpark version
Optionally fixing Windows-specific Spark warnings using winutils.exe

This setup is stable, beginner-friendly, and recommended for learning and local development.

Why PySpark Fails with Python 3.13

The problem isn’t your code—it’s compatibility.

PySpark does not yet support Python 3.13
PySpark 4.x has known issues on Windows
Some internal APIs were removed in Python 3.13 that PySpark still relies on

✅ The correct combination on Windows is:

Python 3.11
PySpark 3.5.x
Java 8 or 11

Step 1: Install Python 3.11 (Side-by-Side)

Do not uninstall Python 3.13. Instead, install Python 3.11 alongside it.

Download Python 3.11 (64-bit):

https://www.python.org/downloads/release/python-3119/
Run the installer:
- Check “Add Python to PATH”
- Click Customize installation
- Enable “Install for all users”
Finish the installation

Verify it worked:

py -3.11 --version

You should see:

Python 3.11.x

Step 2: Allow Virtual Environment Activation in PowerShell

By default, Windows blocks script execution, which prevents virtual environments from activating.

Run this once:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Press Y to confirm.

This change is safe and only applies to your user account.

Step 3: Create a Python 3.11 Virtual Environment

Navigate to your project directory:

cd C:\Users\User\Desktop\Training\Week5

Remove any old virtual environment:

Remove-Item -Recurse -Force venv

Create a new one using Python 3.11:

py -3.11 -m venv venv

Activate it:

venv\Scripts\activate

You should now see:

(venv)

Confirm the Python version:

python --version

Expected output:

Python 3.11.x

Step 4: Install the Correct PySpark Version

Do not install the latest PySpark blindly.

❌ Avoid

pip install pyspark

✅ Install the Windows-safe version

pip install pyspark==3.5.1

Verify:

pip show pyspark

You should see:

Version: 3.5.1

Step 5: Test Your Spark Setup

Create a file called Lab1.py:

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("Test").getOrCreate()

df = spark.range(10)
df.show()

spark.stop()

Run it:

python Lab1.py

If you see numbers from 0 to 9, Spark is running successfully 🎉

Common Mistakes to Avoid

Running Python explicitly from 3.13:
```
C:\...\Python313\python.exe Lab1.py
```
Installing PySpark 4.x on Windows
Using Python 3.12 or newer with Spark
Forgetting to activate the virtual environment

Golden Rule

When (venv) is active, always use python, never a full Python path.

Optional: Fix winutils.exe Warnings on Windows

You may see warnings like:

Did not find winutils.exe
HADOOP_HOME and hadoop.home.dir are unset

Spark works fine without winutils, but adding it removes these warnings.

Which winutils Version to Use

Hadoop version: 3.3.6
Compatible with Spark 3.5.x

Setup winutils

Create this folder:

C:\hadoop\bin\

Place winutils.exe inside:

C:\hadoop\bin\winutils.exe

Set environment variables:

setx HADOOP_HOME C:\hadoop
setx PATH "%PATH%;C:\hadoop\bin"

Restart PowerShell and verify:

winutils.exe

If usage info prints, it’s working.

Final Working Setup

Component	Version
Python	3.11.x
PySpark	3.5.1
Hadoop (winutils)	3.3.6
OS	Windows
Virtual Environment	Enabled

Conclusion

Setting up PySpark on Windows requires careful version alignment, but once configured correctly, it works reliably.

By:

Keeping Python 3.13 installed
Using Python 3.11 in a virtual environment
Pinning PySpark to 3.5.1
Optionally configuring winutils

you now have a stable Spark development environment on Windows.

Happy coding 🚀

RESTART Series: Day 1 – Laying the Foundations

Rachit Avasthi — Mon, 04 Nov 2024 19:20:37 +0000

"The journey of a thousand miles begins with a single step." — Lao Tzu

Hello everyone!

Today marks Day 1 of the RESTART journey, and it’s already been a packed day of learning, building, and revisiting. Here's a breakdown of what I tackled and some highlights:

Revisiting HTML & CSS Basics

To kick things off, I dove back into the Frontend Domination course by Sheriyans Coding School, where I focused on HTML and CSS. Despite having experience with these tools, going back to basics has been refreshing. It's easy to overlook small yet crucial details when you're working at a high level, and today was all about strengthening that foundation. Revisiting HTML tags, CSS positioning, and flexbox tricks reminded me of how powerful even the simplest elements can be when used correctly.

First Full-Stack Project: A Social Media Platform for College

Alongside the HTML and CSS revision, I started building my first full-stack project—a social media platform designed specifically for a college community. It’s ambitious but exciting! I began by planning the core features and laying out the structure. Starting with frontend basics, I’m crafting a design that’s visually appealing but also functional and efficient for student interactions.

Progress in Cloud Computing with AWS

I also completed another module in AWS Cloud Practitioner from GeeksForGeeks. Cloud computing has always been a field I’ve wanted to understand better, and today’s module brought me a step closer to that goal. Gaining more insights into how cloud infrastructure works has already started sparking ideas for future projects. Each lesson in this module is helping me build confidence in AWS and in understanding the potential it brings to backend development.

Goldman Sachs Virtual Internship: Cryptography & Password Security

The highlight of the day was receiving my certificate for completing the Goldman Sachs virtual internship. This experience was a deep dive into the world of cryptography and password security. During the internship, I learned how to analyse password structures, worked on cracking techniques, and explored the best practices for maintaining robust password protection. Knowing these techniques and their ethical applications has been incredibly eye-opening, especially when considering how vital security is in today’s tech-driven world.

Final Thoughts

Day 1 has set the stage for an incredible journey. From brushing up on HTML and CSS fundamentals to diving deeper into cloud computing and cybersecurity, I’m excited about what lies ahead. Tomorrow’s focus will be to progress further in my project and maybe tackle some backend concepts. Stay tuned for more!

Announcing the Start of RESTART: A Journey Back to Basics and Beyond

Rachit Avasthi — Thu, 31 Oct 2024 06:43:02 +0000

“Every moment is a fresh beginning.” — T.S. Eliot

Hello everyone!

I’m thrilled to introduce a new series on this blog called RESTART! This isn’t just any regular journey; it’s a commitment to go back to the basics, relearn and reinforce the skills I already have, and dive into new territories. I’ll be starting from scratch, progressing one step at a time, and I’ll be sharing daily updates on every milestone, challenge, and “aha!” moment.

Why RESTART?

Life moves fast, and with it, our skills and knowledge evolve. However, sometimes in the rush to get better, we miss refining the fundamentals that serve as the foundation of everything we do. RESTART is my way of taking a deep breath, hitting the reset button, and rebuilding from the ground up. I want to ensure my skills are solid, adaptable, and future-ready.

What to Expect

Daily Updates: Each day, I’ll post about what I’ve worked on. This includes recaps, insights, resources, and any breakthroughs along the way.
Skill Building: I’ll be revisiting old skills to make sure they’re sharp, covering basics to advanced levels, and sharing tips to master them. Alongside, I’ll dive into new skill sets, so expect to see fresh insights on tools and technologies.
Engagement: I’d love for this to be an interactive journey. Feel free to comment, ask questions, or share your insights if you’re on a similar journey or just want to follow along.

Goals of the RESTART Series

Strengthen the Core: Ensuring that fundamental knowledge is solid.
Learn Something New: Exploring skills that are essential today, with a focus on growth and relevance.
Document the Process: Through daily posts, I aim to capture the real experience of learning, making mistakes, and growing.

Let’s Begin!

Starting today, I’ll be sharing my journey here, one step at a time. Whether you’re here for inspiration, guidance, or just out of curiosity, I hope you’ll join me as we learn and grow together in this RESTART series.