DEV Community: Sarah Nyambura Kiiru

Understanding REST APIs: A Beginner-Friendly Guide

Sarah Nyambura Kiiru — Fri, 22 Aug 2025 03:56:58 +0000

When building modern web applications, the Frontend (like React) and the Backend (like Django) need a way to talk to each other. This is where APIs (Application Programming Interfaces) come in.

One of the most common types is the REST API (Representational State Transfer). Let’s dive in

What is a REST API?

A REST API is an architectural style for designing APIs that allows communication between client and server using standard HTTP methods.

It works on resources (like users, jobs, or posts) and represents them using URLs (endpoints).

For example:

GET /api/users/      → fetch all users
GET /api/users/1/    → fetch a specific user with ID=1
POST /api/users/     → create a new user

HTTP Methods vs REST API Actions

REST APIs rely on HTTP methods to define what action should be performed.

Here’s the mapping between HTTP methods and their REST meanings:

HTTP Method	REST API Action	Example	Description
GET	Read	`GET /api/jobs/`	Retrieve data (read-only).
POST	Create	`POST /api/jobs/`	Add new data.
PUT	Update (replace)	`PUT /api/jobs/1/`	Update all fields of a resource.
PATCH	Update (partial)	`PATCH /api/jobs/1/`	Update specific fields.
DELETE	Delete	`DELETE /api/jobs/1/`	Remove a resource.

Key Difference:

HTTP method = the protocol action (GET, POST, etc).
REST API action = how that HTTP method is applied to resources in your system.

Commonly Used HTTP Status Codes

When your client (React frontend) talks to your server (Django backend), the server responds with a status code that tells you what happened.

Here are some of the most common ones:

Status Code	Meaning	When it’s used
200 OK	Success	Request was successful.
201 Created	Success	Resource was created (e.g., after POST).
204 No Content	Success	Resource deleted successfully.
400 Bad Request	Client Error	Request was malformed (wrong data).
401 Unauthorized	Client Error	Authentication required or failed.
403 Forbidden	Client Error	You don’t have permission to access this resource.
404 Not Found	Client Error	Resource doesn’t exist.
500 Internal Server Error	Server Error	Something went wrong on the server.

A Quick Example with Django REST Framework (DRF)

In Django, creating a REST API often involves:

Models – define your data.
Serializers – convert models to JSON.
Views – handle requests (GET, POST, etc).
URLs – map endpoints.

Example:

# models.py
from django.db import models

class Interview(models.Model):
    candidate_name = models.CharField(max_length=100)
    date = models.DateField()
    score = models.IntegerField()

# serializers.py
from rest_framework import serializers
from .models import Interview

class InterviewSerializer(serializers.ModelSerializer):
    class Meta:
        model = Interview
        fields = '__all__'

# views.py
from rest_framework import viewsets
from .models import Interview
from .serializers import InterviewSerializer

class InterviewViewSet(viewsets.ModelViewSet):
    queryset = Interview.objects.all()
    serializer_class = InterviewSerializer

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import InterviewViewSet

router = DefaultRouter()
router.register(r'interviews', InterviewViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
]

Now your API endpoints look like:

GET /api/interviews/     → list all interviews
POST /api/interviews/    → create an interview
GET /api/interviews/1/   → fetch specific interview
PUT /api/interviews/1/   → update interview
DELETE /api/interviews/1/ → delete interview

Conclusion

REST APIs allow frontend and backend to communicate using HTTP.
Each HTTP method maps to a REST action (CRUD: Create, Read, Update, Delete).
Status codes help understand what happened with the request.
Django REST Framework makes building REST APIs simpler by providing serializers, viewsets, and routers.

With this foundation, you can confidently connect your React frontend with your Django backend using REST APIs. 🎉

💡 Pro tip: Keep this as a reference whenever you feel stuck in API development!

Day 3: Diving deeply into Models in Django.

Sarah Nyambura Kiiru — Thu, 03 Jul 2025 11:20:19 +0000

Understanding Django Models in Depth with AboutMe and Skill

If you're new to Django, models are one of the core pillars you'll work with. They allow you to define your database structure using Python code, without writing raw SQL.

In this article, we’ll break down two real-world Django models: AboutMe and Skill, used in a personal portfolio-style app.

What Is a Model?

In Django, a model is a Python class that maps to a database table. Each model class represents a table, and each attribute represents a column in that table.

about/models.py

Let’s look at two models:

AboutMe Model

class AboutMe(models.Model):
    name = models.CharField(max_length=100, blank=False, null=False, default="Sarah Nyambura")
    bio = models.TextField(blank=False, null=False, default="A passionate Django learner exploring web development.")
    updated_on = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.name

Breakdown of what the code is about:

Field	Type	Purpose
`name`	`CharField`	Stores the user's name. Max length of 100. Cannot be blank or null.
`bio`	`TextField`	Stores a longer description (bio).
`updated_on`	`DateTimeField`	Automatically updates the timestamp whenever this record is saved.

Skill Model

class Skill(models.Model):
    title = models.CharField(max_length=100, blank=False, null=False, default="Django Web Development")
    about = models.ForeignKey(AboutMe, on_delete=models.CASCADE, related_name="skills")

    def __str__(self):
        return self.title

what the code is about:

Field	Type	Purpose
`title`	`CharField`	Name of the skill (e.g., Python, HTML).
`about`	`ForeignKey`	A many-to-one link to the `AboutMe` model. One person (AboutMe) can have many skills.

on_delete=models.CASCADE: If the AboutMe profile is deleted, all related skills will be deleted.
related_name="skills": Allows you to access skills from an AboutMe instance using .skills.all().

Real-World Usage in my app

The profile says:

Name: Sarah Nyambura
Bio: A passionate Django learner
Skills: Django Web Development, Python, HTML/CSS

This is exactly how your models represent one in code and store it in the database.

Why Models Matter

They are the foundation of your data structure.
Django handles the database for you.
You can use Python to create, update, delete, and query data.

After Creating Models

Don't forget to make and apply migrations:

python manage.py makemigrations
python manage.py migrate

Connecting Models with Views, Templates, and URLs

View: Fetch Data from the Model

To display this data in your browser, connect the view to a URL.

still route the main url of the project

Template: Display It with HTML

this how the output is after starting the developer server

As someone who’s just getting started with Django, working with models felt intimidating at first.
But after building these two AboutMe and Skill I now realize how powerful and structured Django can be. Models allow me to describe the kind of data I want to store without touching SQL at all.
It feels like I’m shaping my website with simple Python classes, and that’s pretty awesome.

My First Hands-On with Django’s MVT (Model, View, Templates) and URLs

Sarah Nyambura Kiiru — Tue, 01 Jul 2025 14:41:33 +0000

Day 2: Here's how I learned about Models, Views, Templates, and URLs and made them work together

To better understand about MVT I used a hotel experience example

1. The Hotel Storage Room (Where All the Info Is Kept)
When one walks in a hotel behind the scenes, there’s a storage room (like a database) where all guest details, room numbers, prices, and bookings are stored.

In Django, this storage space is called the MODEL which holds the data and knows how everything is organized.

2. The Hotel Staff (Who Prepares the Experience)
The hotel staff are responsible for receiving a request one made like when one asks for a room they need to go to the storage room (model) , checks one's reservation, prepare the keys, maybe even add a welcome drink and then give out everything one needs.

In Django, the VIEW does this job. It takes the data from the storage (Model), organizes it, and prepares it for presentation.

3. The Hotel Room (What the Guest Sees)
Now one finally walk into their hotel room.They don’t see the booking files or internal records they just see the beautiful bed, fresh towels, and a welcome note on the table.

This is the TEMPLATE which is the final presentation that the guest (or website visitor) sees. It’s clean, styled, and shows exactly what’s needed.

4. The Hotel Reception Desk (Directing one Where to Go)
When one enters the hotel, they don’t go straight to their room.
They go to the reception desk, tell them what they need, and the staff direct you to the right place.

In Django, this role is played by URLs they guide the request to the correct View, just like reception sends one to the correct floor or room.

In simple terms
A guest makes a request at the reception (URL). The hotel staff (View) checks the storage (Model) for the guest’s booking.The staff prepares the room info and keys.The guest enters the room (Template) and enjoys the experience.

I create a journal app to get hands-on practice

python manage.py startapp <app_name>

For my Journal app that I created I begun applying the MVT Architecture

Firstly I defined a model for the Journal entries in the models.py file

This now is the MODEL concept of the architecture

The next step is to make migrations, This is going to be possible by the use of the following commands:

python manage.py makemigrations journal # journal is the app name 
python manage.py migrate

Secondly, I fetch entries in the journal/view.py file:

This above is the VIEW concept of the architecture

Thirdly, I proceed to pass entries to the template in the journal/templates/journal/journal_entries.html file

This above is the TEMPLATE concept of the architecture

The next step is to route the URL so that whatever has been created will be visible when one visits the browser

Did this in journal/urls.py file

Lastly is to route the url of the main project too.

This above is the URLs concept of the architecture

To ensure that my URL worked on the journal app
I started the developer server

python manage.py runserver

I then visited this link http://127.0.0.1:8000/journal/

This was what was displayed on my browser

I was so happy to see a display on my browser just as a guest gets finally to see the room they had reserved.

How MVT Architecture Works in My Journal App

In the journal app, the Model defines what each journal entry looks like. For example, each entry has: A title , Content.

The View handles the logic. It asks the database for all the journal entries, organizes them (like sorting by most recent), and sends them to a template.

The Template is the HTML file that controls how the entries appear on the page. It takes the data passed from the view and displays it in a clean format using Django’s template language.

The URL tells Django where to send the visitor. When someone visits /journal/, Django uses the urls.py file to know which view function to run.

The flow of my `journal app`

User visits /journal/
urls.py directs that request to the diary_entries view
The view gets all entries from the model
The view sends the data to the template
The template displays the journal entries in the browser

The same procedure I have used to do the journal app you just do that to each app that you create.

Hoping that my approach of the MVT will help you better understand this architecture used in Django.

Come along for 20 days of deep Django learning experience with me

Sarah Nyambura Kiiru — Mon, 30 Jun 2025 18:19:11 +0000

Day 1: How I understood and practiced about the structure of Django

The first thing is to understand what a structure is.

A stucture

is the organized way in which parts of something are arranged or built.It helps one to understand where things belong and maintain one's project as it grows helping in collaboration without confusion.

Django project structure

To be able to have a project structured in the Django style you run the following command to start the project.

django-admin startproject <project_name>

This is how the project structure will look like afterwards:

my_project/
    manage.py 
    my_project/

manage.py - It is a command-line utility used to runserver, migrations etc
my_project (directory with the same name as your project) - This directory contains the project-wide settings and configurations. The files it contained are as below:

my_project/
    __init__.py
    settings.py
    urls.py
    asgi.py

init.py - This empty file tells Python to treat the directory as a package. It's necessary for importing files across different modules something you'll do a lot in Django projects.
settings.py - Contains all the configuration settings for your Django project, such as installed apps, middleware, database settings, static file paths, and more.
urls.py - Acts as the "table of contents" for your site. It defines how URLs are routed to views — basically deciding what happens when someone visits a specific page.
asgi.py - Entry point for ASGI (Asynchronous Server Gateway Interface), which allows your Django app to support asynchronous features like WebSockets and background tasks.
wsgi.py - Entry point for WSGI (Web Server Gateway Interface), which helps traditional web servers like Gunicorn or uWSGI serve your Django project. This is what powers your site in most production environments.

Something to note is to ensure you have created a virtual environment in VS code so as to start the django project
You need to run the server so that to make sure the project runs(a rocket like thing will be displayed in the browser to confirm that)

python manage.py runserver

In order to get to practice on the django structure I created two applications for my day1 learning of django: a journal and an about apps
To be able to create the apps I used:

python manage.py startapp journal
python manage.py startapp about

Each app contains files and a folder which are:
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.

Then I registered the 2 apps in the settings.py file

For the 2 apps I created a folder templates for each.

For the about app the template folder contained an about folder that has an about.html file

For the journal app the template folder contained an journal folder that has an entries.html file

in the settings.py had to tell Django where to find the template

{'DIRS': [BASE_DIR / "templates"],}

Then routed the URL so that the templates to be visible in the browser
I did this by creating urls.pyfile for each app and linking it from view.py file of each app
For journal app view.py

For about app view.py

For journal app urls.py

For about app urls.py

For The whole project URL file urls.py

I then started the developer server
and used this link for me to get results
http://127.0.0.1:8000/journal/diary_entries/

http://127.0.0.1:8000/about/about_me/

My project about creating a diary was complete I had some challenges but got through but did not stop me from proceeding.
This diary apps enabled me to get to understand how the Django structure works.

My Journey Into Git, GitHub & Version Control 💻

Sarah Nyambura Kiiru — Thu, 26 Jun 2025 10:50:54 +0000

🧠 What I Learned About Version Control

I dove into the world of version control and learned how developers use Git and GitHub to manage and collaborate on code projects. Here’s a breakdown of the core concepts I grasped and practiced.

🔁 1. Forking

Forking lets you create your own copy of someone else’s repository under your GitHub account. It’s useful when contributing to open-source projects.

📍 GitHub → Go to a repo → Click “Fork”

👯 2. Collaboration

Git and GitHub make it easy for teams to work together:

Use branches to separate features
Use pull requests to share changes
Communicate through issues and reviews

📬 3. Pull Requests (PRs)

A pull request proposes changes from your fork or branch to the main project.

# After committing your work
git push origin my-branch

Then go to GitHub → Click “Compare & Pull Request” → Submit

⚔️ 4. Merge Conflicts

When two people change the same line of code, Git can’t decide whose changes to keep. This causes a merge conflict.

To resolve:

Git shows conflict markers
You manually fix the code
Then commit the resolved version

🔍 5. Code Review

After opening a PR, other contributors can review your changes:

Leave comments
Suggest improvements
Approve for merging

Code reviews improve quality and teamwork.

🐞 6. GitHub Issues

Issues are used to track:

Bugs 🐛
New features 🌟
Tasks ✅

Example: “Add search functionality”

PRs can reference issues using:

Fixes #5

💻 7. Git Commands I Practiced

git clone <repo-url>                # Copy repo to local machine
git checkout -b new-branch          # Create and switch to a new branch
git add .                           # Stage changes
git commit -m "Your message"        # Save snapshot of changes
git push origin new-branch          # Push changes to GitHub
git pull origin main                # Sync with the main branch

⬆️ 8. Pushing Changes to GitHub

Once I committed my changes:

git push origin feature-branch

Then I opened a pull request and waited for feedback!

🔧 Centralized vs Distributed Version Control Systems

While learning about Git, I also explored the two main types of version control systems (VCS):

🏢 Centralized Version Control Systems (CVCS)

In a centralized system, there is one central server where all versions of a project are stored. Everyone connects to this server to get or submit changes.

Examples:

Subversion (SVN)
Perforce
CVS

Pros:

Simpler to understand
Easier to control access

Cons:

Single point of failure
Requires constant internet connection

🌍 Distributed Version Control Systems (DVCS)

In distributed systems like Git, every developer has a full copy of the project history. Changes can be made locally and pushed later.

Examples:

Git
Mercurial
Bazaar

Pros:

Work offline
Better collaboration
Faster operations

Cons:

Slightly more complex to learn initially

Git is a distributed version control system and that's what makes it so powerful for collaboration!

Learning Git and GitHub gave me superpowers 🦸‍♀️ to work with other developers, track my code history, and contribute to real-world projects with confidence.

“The best way to learn Git is to use Git.”

#git #github #versioncontrol #opensource #womenintech #productivity

Setting Up a Python & Django Dev Environment (Beginner Friendly)

Sarah Nyambura Kiiru — Tue, 24 Jun 2025 12:47:25 +0000

Getting Started with Python and Django

Getting started with Python and Django requires a solid development setup. Whether you're learning back end development or preparing to build your own Django project, this article walks you through the essential tools I installed and configured to get going, all from scratch.

Before writing code, it was important to ensure everything was properly installed and ready from version control tools to editors and container platforms. Here's what I set up on my machine:

Tools I Installed

1. Python 3.13.3

Django runs on Python, so the first thing I did was install the latest stable version of Python which is supposed to be 3.10+.

During installation:

I checked Add Python to PATH

After installation, I confirmed it worked with:

python --version

2. VS Code

I chose Visual Studio Code because it is light, fast, and beginner-friendly.

After installing VS Code:

I installed the Python extension (from Microsoft)
Enabled code formatting, linting, and IntelliSense

3. Git

Git helps manage project changes and is essential for collaboration. It's a must-have tool for any developer.

To install Git on Linux:

sudo apt install git

After setup, I checked the version:

git --version

4. Configure Git with GitHub (Using SSH)

Instead of typing my username and password each time I push to GitHub, I configured SSH authentication. Here's how:

Generate SSH Key

ssh-keygen -t ed25519 -C "your_email@example.com"

Start the SSH agent

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Copy and Add the Key to GitHub

cat ~/.ssh/id_ed25519.pub

Then:

GitHub Settings SSH and GPG keys New SSH key

Test the Connection

ssh -T git@github.com

If successful, GitHub will greet you by your username.

5. Docker (Using Moby Engine)

To run isolated development environments, I installed Docker using the Docker-compatible moby-engine and moby-cli packages on my Kali Linux system.

Here is what I did:

sudo apt update
sudo apt install ca-certificates curl gnupg lsb-release

curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/debian bullseye stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install moby-engine moby-cli -y

Then I started Docker:

sudo systemctl start docker
sudo systemctl enable docker

And tested it with:

docker run hello-world

I got a welcome message confirming Docker works!

Then I restarted the machine to apply the group changes.

This setup gave me everything I needed to start building and managing Django applications efficiently. If you are just starting out with backend development, don't let the setup phase scare you just take it step-by-step.

"Every expert once struggled with installations too."

Feel free to connect if you're setting up your own environment and need help, I'd be happy to share more.

#python #django #git #github #vscode #docker #webdevelopment #womenintech

DEV Community: Sarah Nyambura Kiiru

Understanding REST APIs: A Beginner-Friendly Guide

What is a REST API?

HTTP Methods vs REST API Actions

Commonly Used HTTP Status Codes

A Quick Example with Django REST Framework (DRF)

Conclusion

Day 3: Diving deeply into Models in Django.

Understanding Django Models in Depth with AboutMe and Skill

What Is a Model?

about/models.py

AboutMe Model

Breakdown of what the code is about:

Skill Model

what the code is about:

Real-World Usage in my app

Why Models Matter

After Creating Models

Connecting Models with Views, Templates, and URLs

View: Fetch Data from the Model

To display this data in your browser, connect the view to a URL.

Template: Display It with HTML

My First Hands-On with Django’s MVT (Model, View, Templates) and URLs

Day 2: Here's how I learned about Models, Views, Templates, and URLs and made them work together

To better understand about MVT I used a hotel experience example

How MVT Architecture Works in My Journal App

The flow of my journal app

Come along for 20 days of deep Django learning experience with me

Day 1: How I understood and practiced about the structure of Django

A stucture

Django project structure

My Journey Into Git, GitHub & Version Control 💻

🧠 What I Learned About Version Control

🔁 1. Forking

👯 2. Collaboration

📬 3. Pull Requests (PRs)

⚔️ 4. Merge Conflicts

🔍 5. Code Review

🐞 6. GitHub Issues

💻 7. Git Commands I Practiced

⬆️ 8. Pushing Changes to GitHub

🔧 Centralized vs Distributed Version Control Systems

🏢 Centralized Version Control Systems (CVCS)

Examples:

Pros:

Cons:

🌍 Distributed Version Control Systems (DVCS)

Examples:

Pros:

Cons:

Setting Up a Python & Django Dev Environment (Beginner Friendly)

Getting Started with Python and Django

Tools I Installed

1. Python 3.13.3

2. VS Code

3. Git

4. Configure Git with GitHub (Using SSH)

Generate SSH Key

Start the SSH agent

Copy and Add the Key to GitHub

Test the Connection

5. Docker (Using Moby Engine)

The flow of my `journal app`