Frontend Dev to Full-Stack: Why I’m Relearning Python and Django in 2025

Between 2019 and 2021, I wrote a lot of Python and Django.

I wasn't calling myself a “full-stack developer” or even a developer, back then — I was just building things for fun. APIs, dashboards, admin panels,… fixing bugs for people who asked nicely (and the ones who didn’t, but paid — bills 🫠).

It made sense. Python was clean, Django gave me structure, and I could build fast.

Then in late 2021, React took over my life and I’ve spent most of my career living in the land of useEffect, CSS bugs, and never-ending component trees. React is home — chaotic, but familiar.

I went full frontend, got a job in 2022, and haven't touched Django seriously since.

But now? I’m back. Rusty, but back.

Here’s why I’m relearning Python and Django in 2025 — with fresh eyes, better habits, and a much deeper appreciation for how good frontend and backend can actually work together.

Coming Back Rusty — and a Bit Cocky🔧

First thing I did? Watched (and practiced🌚 yes yes I’m talking to you) a 12-hour Python crash course.

Not because I was starting from scratch — I mean, I used to write this stuff. But after three years of not touching Python seriously, I knew better than to trust my muscle memory. Not even Django — I’m talking full-blown OOP refreshers. Inheritance. Polymorphism. Encapsulation.

Were there a lot of skipped chapters? Yes.

Was there a fair amount of eye-rolling? Also yes.

But every now and then I’d hit a part and go,

“Wait — THAT’S how we do this now?”

Which is ridiculous, because Python hasn’t even changed that much.(Right?? Riiight?? — screams into the void). It’s not like it turned into Elixir while I was gone. But still — some things felt foreign. And some things felt too familiar. Like reaching for console.log() instead of print(). With a semicolon.

It’s amazing how fast you forget syntax, and how stubborn habits from one language follow you into another, like unwanted souvenirs.

It's also funny how when I first moved from Python to JavaScript, I hated the semicolons. They felt so unnecessary. And yet here I am, years later, adding them to my all my statements out of habit. Don’t even get me started on constantly using curly braces when defining my functions.

Programming is weird. Language-switching is weirder.

Lead Brain vs. Hands-on Brain 🧠

Here’s another weird part: I never stopped reading backend code.

From personal endeavors and working as a technical lead, I get to review backend PRs. I can trace logic, spot bad patterns, suggest improvements. I’ve even written up implementation plans for full backend features.

But writing it myself? From scratch?

That’s an entirely different sport.

Like knowing how a car works and then getting thrown into a Formula 1 race. I knew what to do, but my fingers didn’t move the same. The logic was in my brain, but the syntax was off, the structure felt clumsy, and I was slow.

Really, really slow.

It was an exercise in patience. And humility. And boyyy did I google.

Relearning Backend Rhythm (Without the Pretty UI) 👨‍🏫

It’s not that Django was hard. Or unfamiliar. Or even conceptually confusing.

It was just... strange.

The way things were organized, the flow of logic, the expectation of what should happen where — it threw me off. And that’s saying a lot, because I’ve written enough Node.js and Adonis.js to know my way around a backend.

But coming back to Django felt like re-entering a room I used to live in. Everything was mostly where I left it, but something was off. A bit of furniture moved. I couldn’t put my finger on it, but I wasn’t moving around as confidently.

I still believe language isn’t the barrier. Give me a decent crash course and a reason to build, and I’ll figure it out. That’s literally how I started with Adonis — watched two hours of tutorials and boom: backend shipped. (Okay, maybe not boom, and maybe not shipped but you get it.)

Still, Django made me pause.

It made me slow down and adjust. The feedback loop wasn’t visual. There were no buttons to tweak or layouts to adjust. It was just logic. Pure logic. And delayed gratification.

But once I got over the initial discomfort?

It felt kind of amazing.

No CSS bugs. No misaligned components. No “why is this div pushing everything off the screen on mobile.” Just: does the data show up, or does it crash in flames.

Backend is calmer. It either works or it doesn’t. And something about that certainty is… deeply satisfying.

Tools, Setup & Sanity🛠

I didn’t just dive back in with vibes and nostalgia. I had to actually set myself up for success.

Dev setup? VS Code (still), Python 3.12, Django 5, and a fresh respect for virtual environments. I’m not Docker-ing anything yet — it’s local virtualenvs and runserver for now. Keeping it simple.

I started with a 12-hour crash course just to warm up. Yes, I skipped a lot. Yes, I rolled my eyes when he explained what a list is. But then we got to OOP, and I was like “Wait… hold on. Inheritance does what again?”

It wasn’t all muscle memory. Some of it had atrophied. That’s when I realized I needed to relearn, not just remember.

This time around, I’m being more deliberate.
I’m using better naming conventions, committing cleaner, writing docstrings (who is she??), and actually thinking about how this code would feel to other developers down the line.

In 2019, I was building to make it work.
In 2025, I’m building to make it make sense.

My first project this time around?
A content management API with users, roles, permissions, content types, categories — the whole deal. I’ll be releasing an article breaking it all down: the stack, the structure, what went wrong (spoiler: a lot), and what worked better than I expected.

I did not want to build yet another todo list app, but also thought my initial plans might have been a bit too ambitious. So the goal was simple: start with something realistic, and actually finish it.

It’s my "proof of seriousness" — and more than that, a foundation I plan to build on.

Why am i doing this? 🙋‍♀️

Alright👏, I’m almost done yapping. Let’s get into why I’m doing this.

Truth is, the tech landscape has changed. And if I want to keep up (and keep a job), I need to change with it.

As a frontend dev, I’ve built clean, performant UIs. But at some point, it became clear that knowing only the frontend was limiting — not just for my career growth, but for the kind of problems I wanted to solve. I want to build systems, not just screens.

Here’s the thing: a lot of the heavy lifting in software — business logic, data modeling, authentication, scaling — lives on the backend. It’s where the product thinks. The frontend is what users fall in love with, but the backend is what keeps the magic alive.

And now, with AI reshaping everything? It’s even more important to know what’s going on under the hood. Nobody’s shipping serious AI tooling from a useEffect. (I say that with love. You know I do.)

Whether it’s AI, DevOps, or data engineering — I want to get closer to that core. To write code that doesn’t just fetch data, but transforms it, routes it, and makes it usable. To understand the systems that make “intelligent” products possible — and build them myself. Python dominates that space — from ML to data pipelines to API integrations.

And honestly? I’m just ready to grow. Not sideways into yet another frontend framework — but deeper. Into infrastructure. Into systems. Into architecture that scales. Into code that does more than look good.

This move isn’t about abandoning frontend — it’s about expanding my range.

And hey, once I’m caught up? I’ve got some ideas of my own.

But more than that?

I think in all the noise of trying to pay bills and ship tickets, I forgot why I learned how to code in the first place.

I didn’t start this journey chasing titles or jobs. I was just building stuff because it was fun — because it felt like magic that I could make things appear on a screen. I didn’t even apply for a job the first two years I was learning. It was a hobby. A passion.

Somewhere along the way, between deadlines and burnout and staying “industry-relevant,” I lost sight of that.

This shift back to Python, back to the backend, back to systems — it’s not just a career move.

It’s a return.

Advice for Frontend Devs Going Full-Stack🪞

If you’re a frontend dev thinking about diving into backend or full-stack — here’s what I’ve learned so far:

1. Be patient with yourself.
Switching gears isn’t just about syntax or frameworks. It’s a whole different mindset. Backend work involves thinking about data flow, architecture, security, and scaling — things that don’t always have instant visual feedback. Give yourself room to get comfortable.

2. Start small, but think big.
Build tiny APIs, CRUD apps, or simple services first.

Just... not a to-do list app. Please. I believe that should be a misdemeanor by now.

Don’t overwhelm yourself by trying to build a huge system right away.

3. Embrace the command line and documentation.
You’ll live in the terminal more than your IDE at first. Learn to love reading docs, error logs, and debugging without a flashy UI.

4. Don’t ignore the fundamentals.
Brush up on data structures, algorithms, and core concepts like REST, authentication, and databases. They’re your toolkit — no matter the language or framework.

5. Connect with others doing the same.
Full-stack devs often have to learn on the fly. Find communities, forums, or colleagues who can help troubleshoot, review code, and share tips.

6. Know that it’s okay to be rusty or feel lost.
I’m relearning Python and Django after years of focusing on React, and I still get stuck. The difference now? I’m less afraid to ask questions and Google relentlessly.

7. Keep your frontend skills sharp — they’re your superpower.
Understanding the frontend deeply helps you build better APIs and backend logic that actually serve the UI efficiently.

Recap

This isn’t just a tech stack switch — it’s a mindset shift. I’m not here to chase hype or reinvent myself overnight. I’m here to build things that work, understand the systems behind the screen, and grow fully into a developer who ships features from start to finish.

From frontend comfort zones to backend chaos — and maybe even AI or data engineering someday soon — this journey is about depth, not just breadth.

If you’re on a similar path, or just curious how Django fits into all this, stick around. I’ll be sharing the wins, the bugs, the lessons, and probably some rants too.

Let’s build.