Forem: Elizabeth Ng'ang'a

A Django-Based Account Management System

Elizabeth Ng'ang'a — Mon, 07 Jul 2025 14:59:01 +0000

Introduction

Managing user accounts is a core feature of most web applications from login and registration to profile updates and admin controls. In this article, I’ll walk you through how I built User_managment, a simple user management system using Django. This project supports registration, profile editing, and an admin dashboard, with everything tracked on GitHub and tested through unit tests.

1.Project Goals

Here is a brief list of what the project was expected to do;

User registration and login
Profile management
Admin features
Unit tests

2.Tools & Technologies

Django 5.2.4
Python 3.13.3
HTML/CSS (basic styling)
Git & GitHub

3.Project Setup

I had to create and activte my vitual enviroment before i started my project using;

python -m venv venv

Activating

venv\Scripts\activate

I started my project using;

django-admin startproject user_managment

I later started my app

python manage.py startapp user

4.How I set up URLs, templates, static files, and database.

Urls
The project uses Django’s URL routing system to direct users to different pages like registration, login, profile, and admin. We defined routes in both the project-level urls.py and the app-level urls.py inside the accounts app for better organization.
Key paths include:

/register/ – User registration page
/login/ – Login page
/profile/ – User profile view/edit
/admin/ – Django admin panel Below is a screenshot of the URL configuration: Templates The project uses Django’s template system to render HTML pages for user interaction. Each view (like registration, login, and profile) has a corresponding HTML template stored inside a templates/accounts/ directory. Below is a screenshot of the template folder structure:

Features in Detail

_ User Registration_
The project allows new users to create an account using a registration form. The form collects basic details like username, email, and password.

Profile Management (view, edit, change password)

helps the user to update there names change password and add photos.

Admin Panel (manage users)

The project leverages Django’s built-in admin interface to allow superusers to manage registered users. Through the admin panel, the admin can view all users, edit their details, reset passwords, or deactivate accounts. This interface is secured and only accessible to authenticated staff or superusers.

Testing

Django comes with a built-in testing framework based on Python’s unittest module. It allows you to write tests for your models, views, and forms to ensure your application works as expected. In this project, basic unit tests were written to check user creation, profile view access, and form validations.

Git Workflow

After all this i had to commit all my changes and the push my codes.
Here is a screenshoot of my commits;

Here is a link to my repository;
[(https://github.com/1303liz/managment)]

Deployment process

I used railways to deploy my final project here is the link to my deployed project;
[(https://managment-production.up.railway.app/)]

challanges faced

Had a challange during the verification process, and also during the deployment process.
## Lessons Learned

Django views/forms
Auth system
Writing better commits
Writing reusable code
Importance of testing

final thoughts

Building this Django-based user management system was a valuable learning experience. It gave me a practical understanding of how to implement core authentication features such as user registration, login, profile management, and admin control all essential components of most real-world web applications.
Throughout the project, I explored Django's powerful tools like the built-in User model, form handling, the admin interface, and unit testing framework. Writing clean code, following Git best practices with clear commits, and documenting the project helped me structure my development process more effectively.
Although some features like email verification were mocked, the project still simulates a complete flow, from account creation to profile editing and admin oversight. Time constraints made deployment and Docker setup optional, but those remain exciting areas for future improvement.
Overall, this project not only strengthened my Django skills but also deepened my appreciation for well-organized, testable, and user-focused web development.

Ultimate Guide to Django Models

Elizabeth Ng'ang'a — Wed, 02 Jul 2025 19:01:04 +0000

Introduction

In Django, Models are the single, definitive source of truth about your data. They define the structure of your database by mapping Python classes to database tables. Django models are part of the Model-View-Template (MVT) architecture, playing the "Model" role.
What is a Django Model?
A Django model is a Python class that inherits from django.db.models.Model. Each attribute in the class represents a field in the database table.

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13)

This will generate a table in the database with columns: id, title, author, published_date, and isbn.
Meta Class – Model Configuration
The Meta class allows you to configure behavior of your model:

class Book(models.Model):
    title = models.CharField(max_length=200)

    class Meta:
        ordering = ['title']  # Default ordering
        verbose_name = "Book"
        verbose_name_plural = "Books"
        db_table = 'library_books'  # Custom table name

Model Methods
You can define custom methods inside models to add behavior:

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)

    def __str__(self):
        return f"{self.title} by {self.author}"

    def get_author_uppercase(self):
        return self.author.upper()

Example of my model data

CRUD Operations with Models
1.Create – Adding a New Record
2.Read – Retrieving Records
3.Update – Changing Existing Data
4.Delete – Removing a Record
** Model Validation**
Use clean() or full_clean() to enforce custom validations.

def clean(self):
    if self.published_date > timezone.now().date():
        raise ValidationError("Publish date cannot be in the future.")

Advanced Model Features
Custom Managers
it is created by definining a custom manager by subclassing models.Manager.

Model Inheritance
A powerful feature that allows you to reuse common fields or logic across multiple models.

Final Thoughts

Django Models are the backbone of any Django project. They offer a rich, declarative, and powerful way to define, query, and manage your database schema all in clean Python code. Understanding how models work is essential for any Django developer building robust, scalable web applications.

Understanding and implementing the MVT/MVC Architecture in Django.

Elizabeth Ng'ang'a — Tue, 01 Jul 2025 17:26:01 +0000

Introduction.

Modern web applications rely on structured design patterns to stay organized and efficient. One of the most popular patterns is the Model-View-Controller (MVC) architecture, which separates an application into three key components: data (Model), logic (Controller), and user interface (View). Django, a powerful Python web framework, follows a similar pattern called Model-View-Template (MVT). While slightly different in naming, MVT serves the same purpose helping developers manage complex applications by keeping code clean, scalable, and easy to maintain.

(MVC)Model-View-Controller

It is a software design pattern used to separate an application into three main parts. This structure makes web development more organized and easier to manage, especially in large projects.
short description of the 3

Model it basically stores and manages data and also connects directly to the database.
View it mainly handles what the user sees and displays data from the model.
controller mainly shows the user actions and logic and connects the model and the view. That is a short description of each.

(MVT)Model-View-Template

it helps developers manage complex applications by keeping code clean.
short description of the 3

Model Handles the data and database structure.
View Contains the logic fetches data from the model and passes it to the template.
Template Handles the presentation ,displays data to the user using HTML.

Here is an Example from my Waste Sorter project

Models
This is where i defined the data for my two apps in the project
Example of the data i added for the 1st app recycle_tips;

Example of the data i added for the 2nd app waste-logs

Making migrations
makemigrations
After creating the models,this command tells Django to look at your models and check if anything changed (like added fields, new models, or edits).It then creates a file called a migration file which is basically a set of instructions telling Django how to update the database structure.

Here is the code used

python manage.py makemigrations

migrate
This command takes the instructions from the migration file created and actually applies them to your database like creating tables or changing columns.

Here is the code

python manage.py migrate

Editing the view.py ,forms and the Template folder.

After i added the changes to my model and migrated them i had to make my view ,form and templates match with the data added in the models.
views look after editing my models

Forms
I had to create a file by the name"form.py".Its importance is to help import the form classes (like WasteLogForm) inside this file, and then import them in your views as shown in your code.
Example

Templates
I had to update my existing html file under the Templates folder so that they can meet my models requirement.
Example

After making this changes on the views ,forms and the Template there is no need for you to make migrations.You can know test you project using;

python manage.py runserver

Here is my output

How Models, Views, Templates, and URLs Work Together

Here is a short description of how i understood.

we as the user makes request → a URL directs it → View processes → Model fetches data → Template displays it.
you can also follow this and listen for more understanding[(https://www.youtube.com/watch?v=cyP4Uw2b2XM)]
Final thoughts
Understanding the MVC and MVT architecture is key to building clean and well-organized web applications. While MVC is a general pattern used in many frameworks, Django uses MVT, which works in a similar way just with different naming.
In Django:

The Model handles your data,
The View processes the logic,
And the Template displays the result to the user. We also explored how Django’s commands like makemigrations and migrate help us apply changes to the database, and how forms, views, and templates bring everything to life on the web page.

Getting started with Django project

Elizabeth Ng'ang'a — Mon, 30 Jun 2025 18:01:46 +0000

Introduction

Django is a robust and versatile Python framework designed to simplify web development. However, how you start your Django project can significantly impact its scalability, maintainability, and performance. This guide provides a comprehensive, step-by-step walkthrough to help you start your Django project the right way, ensuring a solid foundation for success and also tries to explain the project settings and configurations.

Django Project Structure

project structure in django is designed to support the Model-View-Template (MVT) architectural pattern, which is Django’s version of the traditional Model-View-Controller (MVC) framework.

Step 1

I created a folder on my desktop to hold my project and named it "WASTE SOTOR".

Step 2

I create a virtual enviroment, since am on windows i used,

python -m venv env

This creates a folder named env that will store all project-specific Python packages.
Later i had to activate the enviroment using;

env\Scripts\activate

This is an image after i have created and activated the virtual enviroment it created a folder named env.

Step 4

Install Django
I used;

pip install django

This is are the folders that are created after installing Django, they are created on the env folder.

Step 5

Start a project
I used this since i wanted my project to be called waste_sorter ;

django-admin startproject waste_sorter .

This are the project settings and configurations installed.

checking if my project was working
I had to run my project using;

python manage.py runserver

follow the link provide and you should see this;

1.init.py- Makes the folder a Python package .
2.settings.py-Contains all configurations: database, apps, templates, static files, etc.
3.urls.py-Controls which page shows whatand also connects URLs to views.
4.asgi.py-Used for advanced or real-time features and also handles asynchronous requests.
5.wsgi.py-Used to connect Django to a web server and handles normal (synchronous) requests.

Step 6

In this case i started my app and i had 2 of them using the command;

python manage.py startapp app_name

here is an image both apps i created;

short description of the Django App Components

admin.py: Configuration for the Django admin interface.
apps.py: Configuration for the app itself.
models.py: Contains the database models for the app.
tests.py: Contains tests for the app.
views.py: Contains the request/response logic for the app.
migrations/: Contains database migrations for the app. Registered the apps so that my apps could be recognized ,i opened the settings.py and added the apps on the INSTALLED_APPS.

writing views and creating urls

this are the codes that i wrote, i had two since the apps are two;

Step 7 created Urls for both apps

I created new files and made them "urls.py" under each app.

connecting both Urls
This is where i had to join bothof the urls that i created to the main project.
This is what it looked like;

step 8

Adding Templates
This this the folder that shall be kholding all my pages.
Example of one of my pages ;

Step 9

Checking if the project is Running ;
i used the

python manage.py runserver

then follow the link to the browser .For me i got this;

Conclusion
Starting a Django project the right way sets the foundation for a scalable, maintainable, and efficient web application.The images and step-by-step instructions demonstrate how each component fits together, from the initial runserver check to rendering dynamic templates. Whether you’re building a simple app like "WASTE SOROR" or a complex system, Django’s flexibility and structure empower you to focus on functionality rather than boilerplate.

Git & GitHub: A Beginner’s Guide to Collaboration and Version Control

Elizabeth Ng'ang'a — Thu, 26 Jun 2025 13:05:43 +0000

Introduction
If you're just starting your journey into software development, you've probably heard about Git, version control and GitHub but what exactly are they, and why do developers swear by them?
1.Git is a powerful version control system.
2.version control means you can experiment, roll back mistakes, and collaborate with others without fear of losing work.
3.GitHub is a platform built around Git to make collaboration easier.

Together, they form the backbone of modern software development helping individuals and teams manage code, track changes, collaborate without chaos, and contribute to open-source projects.

This guide will walk you through version control and the essentials of Git & GitHub, from forking a project to managing pull requests, resolving merge conflicts, and everything in between.

1.Version control
Version control is a system that records changes to files over time, so you can track what was changed, when, and by whom.

In software development

it's used to:

Keep a history of every code update
Collaborate with others without overwriting each other’s work
Revert to previous versions if something breaks. Think of it like a time machine for your code allowing you to experiment freely while staying organized and in control.

Forking:Creating Your Own Copy

Forking means creating your own copy of someone else’s repository on GitHub. You can make changes without affecting the original.
why fork?

To contribute to open-source projects
To use someone else’s code as a starting point.

You click the button written Fork.

Collaboration: Working with a Team

It’s when multiple developers work on the same project using Git and GitHub.
How it works
1.Shared Repository:
A central GitHub repository acts as the “source of truth.” Team members clone this repo to work locally and push changes back when ready.
2.Branching:
Each developer works in their own branch (e.g., feature/login-page, fix/button-crash). This isolates work and prevents disruptions to the main branch.
3.Pull Requests (PRs):
When a branch is ready, the developer opens a PR. This lets teammates review the code, discuss changes, and approve before merging.
4.Permissions & Roles:
Admins control access (who can merge, who can push to protected branches)
Contributors usually push to their branches and open PRs for review
Reviewers suggest improvements or approve code before it goes live

Pull Requests (PRs): Merging Changes

A pull request (PR) is a way to propose changes you've made in one branch to be merged into another branch usually the main or develop branch.
Think of a PR like saying:
“Hey team, I’ve made some updates. Can someone review and merge them into the main codebase?”
It’s a key part of collaborative workflows on GitHub and ensures changes are reviewed, tested, and approved before becoming part of the final project.
Why PRs Matter
1.Enable Code Review:
Other team members can review your code, catch bugs, and suggest improvements before anything is merged.
2.Keep Main Branch Clean:
By reviewing changes first, PRs protect the main branch from unstable or broken code.
3.Encourage Team Collaboration:
PRs often lead to discussions around code quality, best practices, or alternative solutions.

How to Create a Pull Request

Step 1:

Create a Feature Branch Locally

git checkout -b new-feature

Make your changes in the project files

Step 2:Stage and Commit Your Work

git add .
git commit -m "Add dark mode feature"

Step 3: Push Your Branch to GitHub

git push origin new-feature

Step 1: Create a Feature Branch Locally

git checkout -b new-feature

Make your changes in the project files

Step 2: Stage and Commit Your Work

git add .
git commit -m "Add dark mode feature"

Step 3: Push Your Branch to GitHub

git push origin new-feature

Step 4: Open the Pull Request on GitHub
Navigate to your repo on GitHub
You’ll see a prompt:
“Compare & pull request” → Click it
Add:
A title (e.g., feat: Add dark mode toggle)
A description explaining what you did and why
Link issues it solves (e.g., Closes #14)
Assign reviewers and labels if needed
Click “Create Pull Request"

Code Review: Improving Code Quality

Code review is the process where team members review each other’s code before it is merged into the main branch. It happens during a pull request (PR) and ensures that all changes meet the project’s standards.
Think of it like proofreading a document before submitting it except you're reviewing code for logic, readability, and potential issues.
Code reviews help improve not just the quality of the code but also the quality of the team's collaboration

GitHub Issues: Tracking Bugs & Tasks

What Are Issues?
GitHub Issues help teams:

Report bugs
Suggest features
Assign tasks

Why Use Them?

Keep development organized
Link PRs to issues with keywords (Fixes #12)

Essential Git Commands

git clone [url] Clone a repo
git status  Show current changes
git add .   Stage changes
git commit -m "msg" Save a snapshot
git push    Upload changes
git pull    Download changes
git branch  List branches

Pushing Changes to GitHub

Create a branch

 git checkout -b fix-navbar

Make changes, then stage & commit

bash git add .

git commit -m "Fix navbar layout issue"

Push changes to your GitHub repo

git push origin fix-navbar

Final Thoughts

Mastering Git and GitHub empowers you to:

Collaborate with other developers
Keep your code organized and versioned
Contribute to open-source
Deliver higher quality software Whether you're solo-building or working on a team, these tools are the foundation of modern development.

Setting Up Your Windows Development Environment Edition

Elizabeth Ng'ang'a — Tue, 24 Jun 2025 22:01:44 +0000

why This Article?
It always feel like a puzzle while starting development on Windows. This guide walks you through exactly how I did it—based on some research i did.

What You'll Set Up
1.Git + GitHub SSH (secure key auth)
2.Python 3.10+ (not from Microsoft Store!)
3.Text Editor(VS Code)
4.WSL2 (Linux on Windows)
5.Docker Desktop

1.Install Git & Configure GitHub SSH
Download the official Git installer from git-scm.com
Run the executable and follow these installation options:
Select "Use Git from the Windows Command Prompt" (adds Git to PATH)

Choose "Checkout Windows-style, commit Unix-style line endings" (recommended)
Pick "Use Windows' default console window" (or "Use MinTTY" if you prefer Git Bash)
Complete the installation and verify in Command Prompt/PowerShell:
bash
git --version
Set Up SSH for GitHub

Install Git & Configure GitHub SSH Download Git from git-scm.com

Set up SSH for GitHub
In Git Bash, run:
bash
Copy
Edit
ssh-keygen -t ed25519 -C "your_email@example.com"
Press Enter 3 times to accept defaults.

clip < ~/.ssh/id_ed25519.pub

Go to GitHub SSH Keys Settings
Click New SSH Key
Paste the copied key into the “Key” field
Name it something like "Windows Laptop"
Click Add SSH Key To test whether you have added the ke correctly you will run this: ssh -T git@github.com

2.Python
You will use this link; https://www.python.org/downloads/
Use the windows option
During installation,

Add Python to Path.
Then install.

After installation use this: (python --version) to check the version.

3.Vs Code
I decided to use (VS Code)as my text editor of choice because it's lightweight, incredibly fast, and very beginner-friendly. It also has a vibrant extension ecosystem, built-in Git support, and seamless integration with tools like Python, Docker, and WSL — making it ideal for both newcomers and experienced developers alike.
use this link to download;https://code.visualstudio.com/

After installation and taking a small tour on the editor , add some extensions

This is how Vs Code look like and its easy to learn and navigate.

4.Install WSL(windows Subsystem for Linux)
This gives a linux enviroment.
In Admin PowerShell Run;
wsl --install

Then restart the laptop when prompted.Choose linux distro(i prefered ubunt since am a beginner).You can set up username and password.

5.Install Docker Desktop for Windows
You can use this link to download;https://www.docker.com/products/docker-desktop/

Download Docker desktop then follow the prompts given and if need be restart your laptop.