I didn't pick up Python because it was trendy. I picked it up because someone challenged me to — and I don't run from challenges.
Five days later, I was knee-deep in Django, Docker, and a codebase that refused to cooperate. This is the story of how a dare turned into a startup, what I learned about switching languages under pressure, and why the struggle was worth every frustrating minute.
The App: Why I'm Building Seendr
Before I get into the technical chaos, let me tell you why any of this matters.
I've been on the other side of the loneliness problem. I've sat on Discord, scrolling through "meet new people" servers, sending messages to strangers and waiting hours — sometimes days — for a reply that often never comes. I've tried group chats that fizzle out after two days. I've opened social media looking for connection and found nothing but highlight reels, follower counts, and a quiet feeling that everyone has friends except me.
And I know I'm not the only one.
Social media was built to connect people. Somewhere along the way, it became a stage. Likes replaced conversations. Follower counts created invisible hierarchies. The platforms we use daily are optimized for engagement, not for friendship. If you don't have the followers, you don't have the voice. And if you're just looking for someone to talk to about something you care about — good luck.
That's what Seendr is for.
Seendr is a video-first mobile app that connects people through shared interests. There are no follower counts. No likes. No vanity metrics at all. You sign up, choose your interests, and get matched with people who share them. From there, you can do a 45-second video "vibe check" to see if there's chemistry, join topic-based debate rooms, or just have a real conversation with someone new.
The idea is simple: what if a social platform treated every user as an equal and gave them a reason to talk?
My teammate and I are building this as a school project and a real startup at the same time. The school requirement was specific — we had to use Django for the backend.
Django means Python. And I had never written a single line of Python in my life.
The Challenge: 5 Days to Learn a Language
I come from the JavaScript/TypeScript world. NestJS, Express, React, Next.js — that's my comfort zone. When I heard "Django," my first reaction was resistance. Why can't I just use what I know?
But then it hit me: this was exactly the kind of challenge I'm always telling other people to embrace. I've said it in conversations, I've thought it during late-night coding sessions — growth happens outside your comfort zone. So when someone essentially dared me to learn Python and build with it, I said yes.
I gave myself five days.
Day 1–2: The Tutorial Phase (False Confidence)
I started with a crash course on Django. Within two days, I understood the structure:
- views.py — where you handle requests and return responses
- urls.py — the routing layer that maps URLs to views
- models.py — your database schema, defined as Python classes
- settings.py — the central configuration file for everything
- migrations/ — Django's way of tracking and applying database changes
- serializers — how data gets converted between Python objects and JSON (via Django REST Framework)
Django calls itself a "batteries-included" framework, and it earns that title. Authentication, admin panel, ORM, middleware — it's all built in. Coming from NestJS where you wire up a lot of things manually, I appreciated that.
I felt good. I felt ready.
I was not ready.
Day 3: The Real Python Hits
Here's the mistake I made: I learned Django's structure but skipped how Python actually works under the hood. Specifically, I glossed over how object-oriented programming is implemented in Python.
And then I tried to write real code.
The syntax felt like someone took everything I knew and rearranged it just enough to be infuriating.
Functions don't use curly braces. They use indentation. And not just as a style choice — the indentation IS the structure. Miss a tab and your code breaks in ways that give you no useful error message.
self is everywhere. In NestJS, when you write a method inside a class, this is implied. In Python, you pass self explicitly as the first argument to every single method. It felt redundant. It felt verbose. It felt wrong.
The syntax for basic things looks alien. List comprehensions, decorators with @ symbols, __init__ as a constructor name, def instead of function — every small difference added friction.
I won't lie. For the first few hours, I was genuinely annoyed. I kept thinking: "This is doing the same thing as what I already know, just in a more annoying way."
Day 4: The Click
And then something happened.
I was writing a view class in Django and realized — I'm still making a class. I'm still writing methods inside it. I'm still receiving a request, processing data, and returning a response. The authentication flow I was building was conceptually identical to the JWT auth system I had built in NestJS for a previous project (a URL shortener).
The patterns were the same. Django just spoke with a different accent.
- NestJS has
@Controller() decorators → Django has urls.py routing
- NestJS has services with business logic → Django has the same, you just organize it differently
- NestJS uses TypeORM or Prisma → Django has its own ORM built in
- Both use middleware, both use serialization, both handle auth with tokens
Once I stopped fighting the syntax and started seeing the underlying architecture, Python stopped feeling foreign. It started feeling like a dialect of the same language I already spoke.
Day 5+: Docker Tried to End Me
Just when I thought I was over the hump, Docker entered the chat.
We were using Docker Compose to run the full stack — Django API, PostgreSQL, Redis, Celery workers. Professional setup, the kind you'd see in a real production environment. I was proud of it.
Then I ran docker compose up and got:
ModuleNotFoundError: No module named 'django'
Django was installed. I confirmed it with pip list inside the container. Python could see every other package. But when the app tried to start, Django didn't exist.
I spent twelve hours on this bug.
The root cause? A combination of three things:
PIPENV_VENV_IN_PROJECT=1 in the Dockerfile was silently overriding the --system install flag, putting packages in a .venv folder inside the project directory- Docker's volume mount was mapping my local
api/ folder over the container's /app directory — which wiped out that .venv at runtime
- A
sed command I used to try to fix the Dockerfile left a trailing backslash that broke the entire ENV block, causing a cryptic build error
So the packages were being installed during the build, then erased when the container started. Django was there. Then it wasn't. Every single time.
I rebuilt with --no-cache more times than I can count. I read Stack Overflow threads from 2019. I stared at logs until my eyes hurt.
Eventually, I reached out to the president of Django Cameroon for help. Because sometimes the bravest thing you can do as a developer is admit you're stuck.
What I Actually Learned
This whole experience — the five-day crash course, the syntax battles, the Docker nightmare — taught me more than any tutorial could.
1. Frameworks are dialects, not different languages.
If you understand how web applications work — routing, middleware, authentication, database operations, serialization — you can learn any framework. The concepts transfer. The syntax is just wrapping paper.
2. Skipping fundamentals will always catch up to you.
I jumped into Django without properly learning Python's OOP model. That shortcut cost me hours of confusion later. Learn the language, then learn the framework. Not the other way around.
3. Docker is simple until it isn't.
Docker Compose looks clean and elegant in tutorials. In practice, the interaction between build layers, volume mounts, environment variables, and package managers can create invisible bugs that steal entire days. Respect the tooling. Read the docs carefully. And always check what your volume mounts are overwriting.
4. Asking for help is a skill, not a weakness.
I used to sit with broken code for hours because I didn't want to seem stupid. This project broke that habit. When you've been stuck for 12 hours and you message someone who solves it in 10 minutes, you stop caring about looking smart. You just want to learn.
5. Constraints breed growth.
If I'd been allowed to use NestJS, I would have. And I would have learned nothing new. Being forced into Python and Django expanded my thinking, gave me a new perspective on backend architecture, and made me a more versatile developer.
Where Seendr Is Now
We're still building. The Django backend is running (finally). The React Native frontend is taking shape with Expo. We've tested Agora's video SDK for the real-time calling feature. The matching algorithm is in its MVP form — simple scoring based on shared interests, age proximity, and location.
There's still a mountain of work ahead: the debate rooms, the moderation system, the 45-second vibe check flow, push notifications, and a hundred other features living in our backlog.
But the foundation is there. And it exists because I said yes to a challenge I wasn't ready for.
If You're Thinking About Picking Up a New Language
Do it. Don't wait until you feel ready. Don't wait until you "have time." Pick a project that forces you to learn, set a deadline that scares you, and start.
You'll be frustrated. You'll write terrible code. You'll hit bugs that make you question your career choices. And then, somewhere around day four, something will click. The patterns will emerge. The syntax will stop fighting you. And you'll realize that you're not starting from zero — you're building on everything you've already learned.
Five days ago, I didn't know Python.
Now I'm building a startup with it.
And honestly? I'm just getting started.
I'm documenting my entire dev journey — from learning new languages to building Seendr — on LinkedIn and here. If you're on a similar path, let's connect. Drop a comment or reach out. We're all figuring this out together.