# Things University Didn't Teach Me About Building Software

Things University Didn't Really Teach Me About Being a Software Engineer

When I was studying software engineering, I thought becoming a software engineer was mostly about writing code.

You learn programming languages.

You learn databases.

You build projects.

You debug things.

You graduate.

Then you become a software engineer.

Simple.

Except nobody really warned me that one day I would be sitting in front of a terminal at 2 AM wondering why Linux decided that I am not allowed to touch my own files.

Permission denied

Excuse me?

I literally created this application.

Why are you fighting me?

And that was when I slowly realised something.

Being a software engineer is not just about writing code.

Sometimes, it is about figuring out why your code works perfectly on your machine but refuses to behave anywhere else.

1. Git is not just git push

At university, Git was mostly:

git add .
git commit -m "final final"
git push

Done.

In real life, Git becomes a whole personality.

You learn about branches.

Merge conflicts.

Rebasing.

Stash.

Cherry picking.

Accidentally committing something you absolutely should not have committed.

And eventually you learn the most important Git lesson:

Always check what you are actually committing.

Because "I only changed one small thing" can very quickly become:

Why is the entire .env file in this commit?

😭

2. Production is a completely different species

Local development is beautiful.

You run:

php artisan serve

And suddenly everything works.

Your database works.

Your CSS works.

Your API works.

Your browser is happy.

You feel powerful.

Then you deploy.

And production looks at your application like:

"Interesting. Anyway, no."

Suddenly you have to think about nginx, PHP FPM, file permissions, environment variables, storage links, queues, logs, DNS, SSL and a whole bunch of things you never thought about when your biggest concern was whether your controller method was returning the correct JSON.

There is a special kind of confidence you get from seeing:

500 Internal Server Error

after everything worked perfectly on localhost.
 

3. Linux permissions are personal

This one deserves its own section.

You eventually learn that files have owners.

Files have groups.

Files have permissions.

PHP needs access to certain directories.

Your web server needs access to certain directories.

And sometimes Laravel wants to write something into storage/framework/views and Linux simply says:

Um... No ❤️

Then you get:

file_put_contents(...): Failed to open stream: Permission denied

At some point you stop being angry and start Googling.

Then you change the permission.

Then Laravel works.

Then you wonder why you didn't learn this earlier.

University taught me how databases work.

Linux taught me humility.

4. DNS is basically the internet's address book

Before actually dealing with domains, I thought DNS was just:

domain name → server

Easy enough.

Then you actually start managing a domain.

A records.

CNAMEs.

Nameservers.

Cloudflare.

SSL.

Subdomains.

DNS propagation.

Suddenly your innocent little domain has become a small administrative department.

You start saying things like:

"Wait, which record is pointing where?"

And somehow you now know more about DNS than you ever expected to.

The funny part is that when everything is configured correctly, nobody notices.

When one thing is wrong, suddenly the entire website disappears from existence.

5. SSL is not just "the lock icon"

I used to think HTTPS was basically:

install SSL → lock icon appears → congratulations

Then you start actually hosting things.

You realise certificates, Cloudflare, origin servers and encryption all have to cooperate nicely.

And then you learn the beautiful phrase:

"It works in HTTP but not HTTPS."

Which is basically the developer version of:

"Everything was fine until it wasn't."

6. Hosting your own website is a very effective way to create more work for yourself

At some point I thought:

"Why don't I just host my own website?"

Which sounds like a reasonable question.

Until you actually do it.

Now you have a machine that needs to stay on.

You need your web server.

You need PHP.

You need your database.

You need your domain.

You need your tunnel.

You need backups.

You need monitoring.

You need to know whether the website is actually alive.

And suddenly your personal website has become a tiny infrastructure project.

I even ended up setting up monitoring so my server can tell me when something goes wrong.

Because apparently I wasn't busy enough.

But honestly, this is one of the things I enjoy about software engineering.

You start with:

"I just want a website."

And somehow end up learning how the internet works from the inside.

7. Cloudflare can become your best friend

I wanted to host my website from home without opening ports on my router.

So I ended up learning about Cloudflare Tunnel.

The concept is actually quite nice.

My home server doesn't need to expose itself directly to the internet.

Instead, the tunnel connects my local server to Cloudflare.

So the flow is basically:

suraiyaanr.com
       ↓
   Cloudflare
       ↓
Cloudflare Tunnel
       ↓
   Home Server
       ↓
      nginx
       ↓
     Laravel

And suddenly my little home PC is serving an actual website on the internet.

Which is pretty cool.

Also slightly terrifying.

8. SSH is something you will eventually love

There is something very satisfying about sitting on your Mac and doing:

ssh ...

and suddenly you are inside another machine.

You can inspect logs.

Restart services.

Edit configuration files.

Check disk usage.

Run commands.

Fix things.

Break things.

Fix the things you just broke.

And eventually you realise:

"Wait. I am basically controlling another computer through text."

That's pretty damn cool.

9. Logs are your new best friend

When something goes wrong, the application usually gives you a clue.

Sometimes.

If you're lucky.

Otherwise, you check the logs.

Laravel logs.

nginx logs.

PHP FPM logs.

systemd logs.

Cloudflare logs.

And suddenly your debugging strategy becomes:

"Okay, show me what happened."

Logs are basically your application's diary.

Except instead of:

"Dear diary, today was difficult."

it says:

ERROR
WARNING
FAILED
Connection refused
Permission denied
502
500

Very emotionally expressive.

10. Backups suddenly become very important

When you're developing locally, deleting something accidentally is annoying.

When you're running an actual application with real data, deleting something accidentally becomes a life lesson.

You start thinking about:

"What happens if this server dies?"

"What happens if the database gets corrupted?"

"What happens if I accidentally delete the wrong directory?"

"What happens if my hard drive decides it has had enough?"

And that is when the word backup starts sounding much more attractive.

Because "I have the source code on GitHub" is not the same thing as "I have everything backed up."

Your database is not magically inside Git.

Your uploaded files are not magically inside Git.

Your server configuration is not magically inside Git.

Future me is usually very grateful when present me remembers this.
 

11. Users will do things you never imagined

This one is probably impossible to teach properly.

You can design your application logically.

You can validate the inputs.

You can add safeguards.

You can think:

"Nobody is going to do that."

Someone will.

They will click something 17 times.

They will submit an empty form.

They will refresh at exactly the wrong moment.

They will upload something weird.

They will use your application in a way you never considered.

And honestly?

That's part of the fun.

Because software isn't really finished when the code works.

It is finished when the software survives actual humans using it.

And humans are unpredictable creatures.

12. Deployment is its own skill

This was probably one of the biggest things I learned after university.

Writing an application and deploying an application are two very different skills.

You can be perfectly comfortable building a Laravel application and still stare blankly at:

nginx
php-fpm
systemd
DNS
SSL
Cloudflare
Linux permissions
environment variables

The first few times, it feels like a completely different field.

But slowly, the pieces start connecting.

Your application needs PHP.

PHP needs PHP FPM.

nginx needs to know where the application lives.

The domain needs to point somewhere.

Cloudflare needs to know where to send traffic.

The filesystem needs the correct permissions.

And suddenly the mysterious black box called "deployment" starts becoming understandable.

13. Sometimes you just need to Google it

This might be the most important lesson of all.

There is a weird expectation that being a software engineer means you should know everything.

You don't.

Nobody does.

Sometimes you know exactly what you're doing.

Sometimes you know roughly what you're doing.

And sometimes you are staring at an error message thinking:

"Okay Google, what the hell is this?"

And that's fine.

The skill isn't memorising every command.

The skill is knowing how to investigate.

Read the error.

Check the logs.

Search the documentation.

Try something.

Break it.

Understand why it broke.

Try again.

Eventually, you learn enough that the thing that used to scare you becomes something you can troubleshoot.

And that is probably what experience actually looks like.

Not knowing everything.

Just being less scared of things you don't know yet.

So, what did university actually teach me?

A lot, actually.

Programming fundamentals.

Algorithms.

Databases.

Software design.

Computer science concepts.

The foundation matters.

But working as a software engineer taught me another side of the job.

How applications actually live outside your laptop.

How servers behave.

How deployments fail.

How DNS works.

How permissions can ruin your afternoon.

How monitoring can save you from discovering a problem through someone else.

How users can break your carefully designed assumptions in five seconds.

And most importantly, how much there is still to learn.

I started as someone who mostly wanted to write code.

Now I find myself learning about servers, infrastructure, deployment, networking, security and all the weird little pieces that make software actually exist in the real world.

And honestly, I kind of like it.

Maybe that's the real thing university didn't teach me.

Being a software engineer isn't about knowing everything.

It's about being curious enough to figure things out.

Also, occasionally:

Googling why Permission denied exists for the 47th time.

And yes.

I still Google it.

–SA