DEV Community: @rinnah

🚀 I Built a Django User Management System in One Day

@rinnah — Mon, 07 Jul 2025 16:13:07 +0000

🚀 I Built a Django User Management System in One Day (And Here's What I Learned)

From zero to fully functional — registration, login, profile, verification, and even testing — all before 6PM!

Hi Devs!
I recently had to build a User Management System using Django — with a tight deadline. The task? Build a complete project with registration, login, mock verification, profile management, an admin panel, and even write unit tests — all in a single day. 😅

So I brewed some strong tea ☕, opened Pycharm, and dove in.

Here's how it went down (and what you can learn from it too).

🛠️ The Tech Stack

Python 3.11+
Django 5.x
SQLite (default for development)
HTML + Bootstrap via Django Crispy Forms
Git + GitHub (with a 10-commit rule!)
Console email backend for mocking verification

📌 Features I Implemented

✅ User Registration
✅ Login / Logout
✅ Email Verification (mocked in console)
✅ Profile View / Edit
✅ Change Password
✅ Admin Panel for managing users
✅ Tests for models and views

And yes — everything works 🥳

📁 Project Structure

My Django project followed this structure:

user_mgt/
├── accounts/           # Custom user app
│   ├── models.py       # Extended User if needed
│   ├── views.py        # Auth + profile views
│   ├── forms.py        # Crispy-powered forms
│   └── tests.py        # Unit tests
├── user_mgt/
│   └── settings.py     # Configured apps, email, templates
├── templates/
│   └── registration/   # login.html, register.html, etc.
├── static/             # CSS, images, etc.
├── manage.py
└── README.md

I didn’t use any fancy custom user model yet, but made the app scalable to add it later.

🧱 Step-by-Step Breakdown

1. Project Setup 🧰

django-admin startproject user_mgt
cd user_mgt
python manage.py startapp accounts

I added accounts, crispy_forms, and set up templates and static directories in settings.py.

2. User Registration 🔐

I created a RegisterForm that extended UserCreationForm, then used a class-based view to render it. Thanks to crispy-forms, it looked great with minimal CSS.

class RegisterView(View):
    def get(self, request):
        form = RegisterForm()
        return render(request, 'registration/register.html', {'form': form})

    def post(self, request):
        form = RegisterForm(request.POST)
        if form.is_valid():
            user = form.save()
            # send email here (mocked)
            return redirect('login')
        return render(request, 'registration/register.html', {'form': form})

3. Email Verification (Mocked) 📬

I used Django's built-in console backend:

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

So when a user signs up, it "sends" a verification link in the console — simple, elegant, and demo-ready.

4. Profile Management 👤

Profile View: Display user details
Profile Edit: Allow users to update name, email, etc.
Password Change: Using Django’s built-in views

Each normal user could only view and edit their profile — nothing more. Security first. 🔐

5. Admin Panel 🛠️

Django’s admin is magic 🪄. I just registered my User model, customized the display, and boom — I could view and edit all users easily.

6. Unit Testing 🧪

I wrote simple tests for:

✅ Model creation
✅ View rendering for login and registration

class UserTestCase(TestCase):
    def test_user_creation(self):
        user = User.objects.create_user(username="dee", password="123asd45")
        self.assertEqual(user.username, "dee")

Small but mighty!

🤯 Lessons Learned

Django does a LOT for you. From auth to admin to email, it's a full-stack powerhouse.
Crispy Forms = 🔥 Makes your forms look instantly professional.
You don't need to reinvent everything — use built-in tools first, then customize.
Console email is your friend during development.
Writing tests early makes you more confident — even if they're simple.

✅ Final Deliverables

✔️ GitHub repo with <10 commits
✔️ README with setup + screenshots
✔️ Working registration, login, profile, and admin
✔️ Tests added

📦 What’s Next?

I’m planning to:

Deploy this on Render or Railway
Add a Docker setup for easier deployment
Maybe write a Part 2: Advanced User Roles + Permissions!

🔗 Check Out the Code

👉 GitHub Repository

🧠 Final Words

This project pushed me to:

Think fast 🧠
Code clean 🧹
Write meaningful commits 📝
And learn a LOT about Django authentication in just one day

I hope this walkthrough helps you if you're learning Django, or rushing to finish your own project like I was 😅.

💬 Questions? Suggestions?

Drop them below or ping me on GitHub — happy to connect and grow together as devs! 🙌

Day 5: Understanding Django’s MVT vs MVC – Models, Views, Templates & URLs Demystified!

@rinnah — Tue, 01 Jul 2025 18:10:31 +0000

🎉 Welcome to Day 5 of Django Journey!

Today, we break down the architecture that powers Django apps — the MVT pattern — and compare it to the classic MVC. If you've heard about Models, Views, Templates, and got confused, you're not alone! Let’s untangle that web. 🕸️

🧠 MVC vs MVT — What’s the Difference?

Before diving into Django specifics, let’s explore what these patterns mean.

🧩 MVC (Model-View-Controller)

This pattern separates your application into:

Model – The data and database layer.
View – The UI or frontend display.
Controller – The logic that controls data flow between the Model and View.

Used in frameworks like Laravel, Ruby on Rails, and ASP.NET.

🧩 MVT (Model-View-Template) in Django

Django follows MVT, which looks very similar:

Model – Represents data (just like MVC).
View – Handles logic and pulls data from the model.
Template – The HTML interface shown to users.

But here's the twist:

In Django, the View is like the Controller in MVC, and the Template acts as the View.

📘 Learn more: Django vs MVC on Real Python

🏗️ Let’s Understand Each MVT Component

🔹 1. Model – Your Data's Structure

The Model defines how data is stored in the database using Django’s ORM (Object Relational Mapping). It avoids writing raw SQL.

Example:

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()

Models map directly to database tables.
Each class = 1 table, each field = 1 column.

📘 Django Models Guide

🔹 2. View – The Brain 🧠

The View is the middleman. It receives user requests, talks to the model, then selects the template to display.

Example:

python def home(request): posts = BlogPost.objects.all() return render(request, 'home.html', {'posts': posts})

Think of Views as your app’s logic and decision maker.
It returns a response, usually HTML.

📘 Django Views Explained

🔹 3. Template – The Frontend

Templates are what users see — HTML files with dynamic placeholders.

Example:

html {% for post in posts %} <h2>{{ post.title }}</h2> <p>{{ post.content|truncatewords:20 }}</p> {% endfor %}

Templates use Django Template Language (DTL).
They display data passed by the view.

📘 Django Templates

🔹 Bonus: URL Routing

Django uses a URL dispatcher to connect browser paths to views.

Example:

python path('', views.home, name='home')

📘 Django URL Patterns

🧭 The Flow of Data (Visual Recap)

plaintext Browser Request ↓ URLConf (urls.py) ↓ View (views.py) ↓ Model (if needed) ↓ Template (HTML page) ↓ Browser Response

🔐 Admin Panel – MVT in Action

python admin.site.register(BlogPost)

Then visit 127.0.0.1:8000/admin after running:

bash python manage.py createsuperuser

📘 Django Admin Docs

Day Four of My Django Bootcamp: Crafting the Structure of My Django Project

@rinnah — Mon, 30 Jun 2025 18:28:29 +0000

Day Four of My Django Bootcamp: Crafting the Structure of My Django Project

Today is the fourth day of my Django bootcamp, and it has been an exciting journey so far! I focused on creating and structuring my Django project while learning a lot about apps, templates, and URL configurations. Here’s a friendly walkthrough of how I accomplished it using Git Bash as my terminal.

1. Starting the Django Project 🚀

The first step was to create a new Django project named dijango. This project would serve as the foundation for everything else. Using Git Bash, I navigated to my desired directory and set up a virtual environment:

mkdir dijango
cd dijango
python -m venv venv
source venv/bin/activate  # For Linux/macOS
venv\Scripts\activate   # For Windows

Next, I installed Django and created the project:

pip install django
django-admin startproject dijango .

Here’s what the structure looked like at this point:

manage.py: The project’s control center.
dijango/: A directory containing core files like settings.py, urls.py, and others.

2. Creating Applications 🛠️

Django encourages splitting functionality into smaller units called apps. I created two apps, REE1 and REE2, to separate different functionalities:

python manage.py startapp REE1
python manage.py startapp REE2

Each app came with its own files, like views.py and models.py. To make Django recognize these apps, I added them to the INSTALLED_APPS section in settings.py:

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'REE1',
    'REE2',
]

3. Setting Up Templates 🎨

Templates define how the front-end of the app looks. Using Git Bash, I created a templates directory in the root folder and added subfolders for each app:

mkdir templates
mkdir templates/REE1
mkdir templates/REE2

In settings.py, I updated the TEMPLATES configuration to include the new directory:

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

4. Configuring URLs 🌐

URL configurations connect specific views to URLs. Since Django doesn’t create urls.py files for apps by default, I manually added them for REE1 and REE2.

For REE1/urls.py:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='ree1_index'),
]

For REE2/urls.py:
jy

from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='ree2_home'),
]

I then updated the main project’s urls.py to include these app-specific routes:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('ree1/', include('REE1.urls')),
    path('ree2/', include('REE2.urls')),
]

5. Adding Views and Templates 🖼️

In Django, views determine what gets displayed for each URL. I created simple views for both apps:

For REE1/views.py:

from django.shortcuts import render

def index(request):
    return render(request, 'REE1/index.html')

For REE2/views.py:

from django.shortcuts import render

def home(request):
    return render(request, 'REE2/home.html')

Next, I added basic HTML templates:

templates/REE1/index.html:

<!DOCTYPE html>
<html>
<head>
    <title>REE1 Index</title>
</head>
<body>
    <h1>Hello I am Rinnah. Welcome to REE1 app index page.</h1>
</body>
</html>

templates/REE2/home.html:

<!DOCTYPE html>
<html>
<head>
    <title>REE2 Home</title>
</head>
<body>
    <h1>Welcome to REE2!</h1>
</body>
</html>

This is the outcome of after testing

Using Git Bash throughout this process made it easy to execute commands and navigate between directories. As I continue exploring Django, I look forward to building more complex projects and honing my skills. If you’re on a similar journey, let’s connect and share our progress!

Beginning My Django Journey: A Dive into Version Control and Collaboration

@rinnah — Thu, 26 Jun 2025 11:58:15 +0000

Starting my journey into Django development has been both exciting and challenging. One of the key lessons I’ve learned early on is the importance of version control and collaboration tools like Git and GitHub. These tools have become indispensable in helping me understand how to manage code effectively and work with others in a structured way. 🚀

🍴 Forking

What is forking?
Forking is like creating your own sandbox to play in! 🎮 It lets me copy someone else’s repository and experiment without worrying about breaking the original. The Atlassian Git Tutorials gave me a great head start on understanding this process.

🤝 Collaboration

Collaboration is the secret sauce of successful development! 🥗 Platforms like GitHub and GitLab make it easy to work with teammates. By creating branches, I’m learning how to independently develop features while staying aligned with the main project. Tools like pull requests and code reviews ensure smooth integration—a lifesaver when working in groups. 🎉

📩 Pull Requests

Pull requests (PRs) are a fantastic way to propose changes. 📝 They let me request feedback and make improvements before merging updates. GitHub Learning Lab has amazing tutorials on mastering PRs.

⚔️ Merge Conflicts

Oh, merge conflicts—the friendly sparring partner of coding. 😅 They happen when two people make changes to the same part of a file. Learning how to resolve these gracefully with guidance from GitHub Docs has been invaluable. It’s a skill that’s now second nature! 🛠️

🕵️‍♂️ Code Review

Code reviews are like having a personal mentor for every pull request. 👨‍💻👩‍💻 They ensure the code meets project standards and is bug-free. This practice also fosters collaboration and helps beginners like me grow. Check out GitHub’s best practices for code reviews to see why they’re so impactful.

🐛 GitHub Issues

GitHub Issues are a project’s to-do list! ✅ They help track bugs, plan features, and manage tasks efficiently. They’re a must-have tool for staying organized and productive. Learn more about managing Issues from GitHub’s resources.

🔧 Git Commands

Learning Git commands has been a game-changer for me. 🎮 Here are the ones I use most:
• git clone: Copy a repository to my local machine.
• git add: Stage changes for a commit.
• git commit: Save changes to my local repository.
• git push: Upload commits to a remote repository.
• git pull: Fetch and merge updates from a remote repository.
• git status: Check the state of my repository.
• git branch: Manage branches.
These commands are the bread and butter of version control. 🍞 For anyone just starting, Atlassian’s Git tutorials are super helpful.

🚀 Pushing Changes to GitHub

The process of pushing changes is straightforward and satisfying. 😊 After staging and committing with git add and git commit, I use git push to upload my work to GitHub. This ensures my updates are safe and accessible to collaborators. GitHub’s resources made this process a breeze to learn.

🎉 Final Thoughts

Diving into Django has been an incredible learning experience, and mastering version control has made it even more rewarding. Tools like Git and GitHub not only streamline workflows but also open doors to meaningful collaborations. 🌍
If you’re on a similar path, I recommend exploring resources like GitHub Docs, Atlassian Git Tutorials, and GitLab’s guides.
Here’s to more learning and building with Django—happy coding! 🧑‍💻👩‍💻

My First Dev.to Article

@rinnah — Tue, 24 Jun 2025 20:16:23 +0000

👋 Hello Dev.to community!

This is my very first article on Dev.to! I’m excited to start writing and sharing what I learn on my web development journey.

So far, here’s what I’ve done:

✅ Installed Git and created a GitHub account
1. Went to git-scm.com and downloaded Git for Windows.
2. Followed the installation prompts.
3. Signed up at github.com and created an account.
4. Configured Git with:
```
 git config --global user.name "rinnah-oyugi"
 git config --global user.email "reeoyugi@gmail.com"
```
✅Installed Python
1. Downloaded Python from python.org.
2. Made sure to check the box "Add Python to PATH" during installation.
3. Verified installation by running:
```
 python --version
```
✅Using PyCharm as my code editor
1. Downloaded PyCharm Community Edition from jetbrains.com.
2. Installed and set up a basic Python project.
3. Linked it with Git for version control.
✅Running Ubuntu on Windows through WSL (Windows Subsystem for Linux)
1. Enabled WSL by running this in PowerShell (Admin):
```
 wsl --install
```

Installed Ubuntu from the Microsoft Store.
Set up username and password.
Updated Ubuntu with:
```
 sudo apt update && sudo apt upgrade
```

✅ Configured Git with GitHub using SSH
1. Generated SSH key with:
```
 ssh-keygen -t ed25519 -C "reeoyugi@gmail.com"
```

Added SSH key to the ssh-agent.
Copied the public key using:
```
 cat ~/.ssh/id_ed25519.pub
```
Pasted it into GitHub → Settings → SSH and GPG keys.
Tested connection:
```
 ssh -T git@github.com
```

Setting up of Docker

Installed Docker Desktop from docker.com.
Enabled WSL 2 integration for Ubuntu in Docker settings.
Verified installation with:
```
 docker --version
```
Ran my first container using:
```
 docker run hello-world
```
Successfully tested Docker with simple linux containers and docker-compose!

🎉 It’s been a great learning experience so far. I’m looking forward to learning even more and sharing my progress with you all.

Thanks for reading!