Blog

Is Android’s Firewall Weaker Than Windows?

I was building Noodle(an app that helps you with your overthinking. Click to know more).

And I had to ping my FastAPI on my laptop from the mobile app.

I needed my mobile app to talk to my FastAPI backend running on my laptop.

The usual developer ritual:

“Both devices on the same network → use laptop IP → connect.”

So I connected my laptop and phone to the same hotspot.

Simple.

Except…

It didn’t work.

My phone couldn’t reach FastAPI.

After some debugging, I tried something random.

“Can my laptop even see my phone?”

I pinged my phone’s IP from my laptop.

Success.

Okay.

So the phone exists.
The network works.

Then why can’t my phone talk to my laptop?

My first thought:

“Is my laptop firewall blocking this?”

And then the bigger question hit me:

Wait…

Is my phone less secure than my computer?

Should I install a firewall on my Android, too?

Let’s see.

Then I learnt about sandboxing.

On Windows, a computer is built like a general-purpose machine.

You can run:

• servers
• databases
• development tools
• file sharing
• remote access services

And these things can listen on network ports.

Example:

Laptop

Port 8000
     |
     ↓
FastAPI server

If something is exposed and allowed through the firewall, another device can talk to it.

That’s why Windows needs a firewall.

It is controlling which doors are open.

But with Android, every running app is in its own delusional (real but not real) box.

Called sandbox.

Apps are isolated from each other.

• WhatsApp doesn’t just walk into another app’s data.
• Instagram can’t casually open WhatsApp’s files.

The operating system controls the boundaries.

So is Android’s firewall weaker?

Not really.

Android and Windows are protecting different things.

Windows says:

“Many powerful things can run here. Let’s control the doors.”

Android says:

“Each app gets its own room. Don’t let them enter each other’s rooms.”

Both are security strategies.

And my tiny FastAPI debugging problem accidentally led me into understanding how operating systems create trust boundaries.

A networking bug became a security lesson.

Classic developer moment.