DEV Community: Mostafa Hatem

Before Writing Code, Understand the Process: My Introduction to SDLC

Mostafa Hatem — Wed, 04 Nov 2026 18:49:28 +0000

When I started learning software development, I mainly focused on the coding part: writing functions, creating models, building APIs, and solving programming problems.

But there's something important I wanted to understand better:

How does a software project actually go from an idea to a working application?

That's where I learned about the Software Development Life Cycle (SDLC).

What Is SDLC?

SDLC stands for Software Development Life Cycle.

It's a structured process that helps development teams plan, design, build, test, deploy, and maintain software.

Instead of immediately starting to code, teams follow an organized process to understand what they're building and how they should build it.

Think about building an e-commerce application.

Before creating Django models or API endpoints, you need to know:

What problem does the application solve?
Who will use it?
What features are required?
How should the database be designed?
How will the application be tested and deployed?

SDLC helps organize these decisions.

The Six Phases I Learned About

1. Planning

Understand the problem, gather requirements, define project goals, and estimate resources.

One important document introduced in this phase is the Software Requirements Specification (SRS), which describes what the software should do.

2. Design

Plan how the application will work technically.

This includes architecture, database design, components, and relationships.

3. Development

This is where developers write code and implement the planned functionality.

For a Django REST Framework project, this could mean creating models, serializers, views, URLs, and permissions.

4. Testing

Verify that the application works as expected.

Some common testing types are unit, integration, system, and acceptance testing.

5. Deployment

Release the application into an environment where users can access it.

6. Maintenance

Fix bugs, improve performance, address security issues, and introduce new features after release.

Waterfall vs. Iterative Development

I also learned that SDLC doesn't always follow one fixed sequence.

The Waterfall model generally moves through phases sequentially.

Iterative development, on the other hand, allows teams to revisit previous phases, collect feedback, and improve the software through repeated cycles.

This makes development more adaptable when requirements change.

Another Interesting Concept: Prototyping

A prototype is an early, simplified representation of a software idea.

It helps stakeholders visualize proposed features and provide feedback before the complete application is developed.

For example, a team planning an e-commerce application might create a basic product page mockup to understand how users will interact with it.

My Main Takeaway

Before this lesson, I mostly associated software development with writing code.

Now I understand that building software involves much more than implementation.

Planning, understanding requirements, designing the architecture, testing, deployment, and maintenance are all important parts of the process.

As I'm continuing my backend development journey with Python and Django REST Framework, understanding SDLC gives me a better perspective on how real-world software projects are organized.

I'm still learning, and this is one more concept I'm adding to my developer toolbox.

Question for other developers:

When working on a project, which SDLC phase do you think developers tend to underestimate the most: planning, design, testing, or maintenance?

I'd love to hear your thoughts!

My First Step into Software Engineering: It's More Than Just Writing Code

Mostafa Hatem — Wed, 04 Nov 2026 14:21:26 +0000

When I started learning backend development, I thought building software was mainly about writing code.

But as I started the IBM Back-End Development Professional Certificate, I realized something important: writing code is only one part of building software.

So, I decided to start documenting my learning journey, beginning with a fundamental question: What is Software Engineering?

What Is Software Engineering? Understanding the Foundations of Building Software

My Backend Development Learning Journey | IBM Back-End Development Professional Certificate

I'm currently starting my journey through the IBM Back-End Development Professional Certificate. Before diving deeper into backend technologies like Python, Django, databases, and APIs, I started with an important question:

What is Software Engineering, and why do we need it?

At first, I thought software development was mainly about writing code to build applications. But I started understanding that building reliable software involves much more than programming.

Let's explore what I learned.

1. What Is Software Engineering?

Software engineering is the application of engineering principles, systematic methods, and tools to design, develop, test, deploy, and maintain software.

In simpler terms, software engineering is about building software in an organized and reliable way to solve real-world problems and meet user and business requirements.

A real-world analogy

Imagine you're building a custom car.

You wouldn't just start assembling random parts. You would:

Understand what the customer needs.
Design the car.
Select the appropriate materials.
Build the different components.
Test the car for safety and performance.
Maintain and improve it over time.

Software engineering follows a similar approach.

Instead of physical components, we work with code, databases, APIs, architectures, and software tools.

The goal isn't simply to make software work. It's to make it reliable, maintainable, efficient, and useful.

2. The History: What Was the Software Crisis?

To understand why software engineering became important, we need to look at the history of software development.

During the early days of computing, programming practices were relatively informal compared with today's standards.

As computers became more powerful, software systems became larger and more complex.

Developers started facing serious challenges, including:

Projects exceeding their budgets.
Development taking longer than expected.
Software containing numerous bugs.
Systems becoming difficult to maintain.
Applications failing to meet user requirements.

These challenges became known as the Software Crisis.

The term gained prominence during the 1968 NATO Software Engineering Conference, where experts discussed the growing difficulties of developing large software systems.

How did the industry respond?

The industry began adopting more systematic engineering practices, including:

Standardized development processes.
Structured programming.
Software design principles.
Testing and quality assurance.
Documentation.
Computer-Aided Software Engineering (CASE) tools.

CASE tools help automate or support software engineering activities such as modeling, design, documentation, and testing.

These approaches helped the industry manage software complexity and improve development practices.

However, software engineering didn't magically eliminate every software development problem. Managing complexity, cost, time, and quality remains an important challenge today.

3. Software Engineer vs. Software Developer

One interesting thing I learned is that software engineering and software development are related, but they aren't exactly the same concepts.

A useful way to understand the distinction:

Software Engineering is a discipline that applies engineering principles to the entire software lifecycle.

Software Development is the practical process of creating and improving software.

Software engineers often consider the bigger picture, including:

System architecture.
Scalability.
Reliability.
Security.
Maintainability.
Technical requirements.

Software developers focus on implementing software functionality, such as:

Writing code.
Building application features.
Integrating components.
Fixing bugs.
Testing functionality.

However, these responsibilities overlap significantly. In many companies, the titles Software Engineer and Software Developer are used interchangeably.

A backend developer, for example, might write API endpoints while also making architectural decisions and considering database performance.

The important thing is to understand that software engineering is more than just writing code.

4. Connecting Software Engineering to Backend Development

Let's imagine we're building an e-commerce application using Python and Django.

The application needs:

User registration and authentication.
Product management.
Shopping cart functionality.
Order management.
Database integration.
API endpoints.
Security and permissions.

We could immediately start writing Django code.

But an engineering mindset encourages us to ask questions first:

What exactly should the application do?
Who will use the application?
How should the database be designed?
How should different components communicate?
How will we protect users' information?
How will we test and maintain the application?

These questions help us move beyond simply writing code and start thinking about building complete software systems.

5. Key Takeaways

Here are the most important things I learned from this lesson:

Software engineering is more than programming.
Building reliable software requires planning, design, development, testing, and maintenance.
The Software Crisis highlighted the difficulties of managing large software projects.
Engineering principles and structured development practices help manage software complexity.
Software engineers and software developers have overlapping responsibilities.
Understanding the entire software system is important, especially when developing backend applications.

Final Thoughts

This lesson changed how I think about software development.

Previously, I mostly associated building applications with writing code. Now, I'm starting to understand that writing code is only one part of a much bigger process.

As I continue learning backend development, I want to focus not only on how to implement something, but also on why we implement it in a particular way.

That's the mindset I want to develop throughout this journey.

Learning source: IBM – Introduction to Software Engineering (Coursera)

Learning series: IBM Back-End Development Professional Certificate

This article represents my personal understanding and notes from the course. I'm documenting my progress as I learn, explore, and build my skills in backend development.

What is Django & Django REST Framework? Should You Learn Them?

Mostafa Hatem — Wed, 09 Sep 2026 17:23:19 +0000

What is Django REST Framework?
If you interested in web development, you have probably heard of Django and Django REST Framework.

But What exactly are they?
what is the difference between Django and Django REST Framework?
And most importantly -- Should you learn them?
let's break it down.

What is Django?

Django is a high-level web framework built with Python.
A web framework provides developers with tools and structures that make it easier to build web applications without having to implement everything from scratch.

instead of spending your time building basic functionality such ad:

URL routing
Database interactions
User authentications
Security mechanisms
Form handling
Administrative interface

Django provides many of these features ad part of its ecosystem,

This allows developers to focus more on the actual functionality and business logic of their applications.

What can you build with Django?

Django can be used to build many types of web applications, including:

E-commerce platforms
Social networks
Content management systems
SaaS applications
Dashvoards
Booking systems
Educational platforms
Business management systems
APIs and backend services

Django is also known for following the principle:

"Don't Repeat Yourself"

It provides a structured approach to developing applications, which makes projects easier to maintain and scale.

What is Django REST Framework?

Now let's talk about Django REST Framework, commonly known as DRF.

Django REST Framework is a powerful toolkit built on top of Django for creating Web APIs.

But what does that actually mean?

Imagine you have an application with users and products.

Your application might need to retrieve information about products from the server.

Instead of returning an HTML page, an API can return structured data such as JSON:

{
  "id": 1,
  "name": "laptop",
  "price": 30000,
}

Another application can then consume this data.

For example:

Web Application
       ↓
    HTTP Request
       ↓
Django REST Framework
       ↓
    Database
       ↓
    JSON Response
       ↓
    Application

This makes DRF useful for building backends that communicate with different types of clients.

Why do we need APIs?

Modern applications are not limited to traditional websites.

Today, the same backend might need to communicate with:

Web applications
Mobile applications
Desktop applications
Other services
IoT devices

Instead of building a completely separate backend for every client, you can expose your application's functionality through APIs.

For example:

      Django + DRF
                      │
          ┌───────────┼───────────┐
          ↓           ↓           ↓
        Website     Mobile      Other
        App         App         Services

All of them can communicate with the same backend through APIs.

This is one of the main reasons REST APIs have become such an important part of modern software development.

Django vs Django REST Framework

So what's the difference?

The simplest way to understand it is:

*Django is the web framework.
*
*Django REST Framework is a toolkit for building APIs with Django.
*
Django provides the foundation:

URL routing
ORM
Authentication
Security
Middleware
Database integration
Admin interface
Application structure

DRF builds on top of Django and adds tools specifically useful for APIs, such as:

Serializers
API Views
ViewSets
Routers
Permissions
Authentication
Pagination
Filtering
Browsable API

So DRF isn't really a replacement for Django.

It extends Django for API development.

Why Learn Django?

There are several reasons why Django is worth considering.

*1. Python
*
Django is built with Python.

Python is one of the most widely used programming languages and is used in many areas including:

Web development
Data science
Artificial intelligence
Automation
Scientific computing

Learning Django also gives you practical experience using Python to build real applications.

2. Batteries In

One of Django's biggest advantages is that it provides many things you need to build a web application.

Instead of assembling dozens of unrelated libraries for basic functionality, Django provides a large set of built-in tools.

For example, Django includes:

ORM
Authentication
Admin panel
Security features
URL routing
Forms
Middleware
Sessions
Migrations

This approach can significantly speed up development.

3. Django ORM

Django includes an ORM —** Object-Relational Mapper.**

It allows you to interact with databases using Python objects and queries instead of writing SQL for every operation.

For example:

Product.objects.filter(price__gt=1000)

The **ORM **translates this into the appropriate database query.

This makes working with databases much more convenient, especially when building complex applications.

Why Learn Django REST Framework?

If you're interested in building APIs, DRF has several advantages.

*1. It Works Naturally With Django
*
If your application already uses Django, DRF integrates directly with it.

You can use Django's:

Models
ORM
Authentication
Permissions
Admin
Middleware

while adding API functionality through DRF.

2. Serializers

One of the most important concepts in DRF is the Serializer.

A serializer helps convert complex data such as Django model instances into formats that can easily be sent through an API, usually JSON.

For example:

Django Model
     ↓
Serializer
     ↓
   JSON
     ↓
API Client

It can also handle incoming data and validate it before it reaches your application.

3. Authentication and Permissions

Real applications need to control who can access what.

For example:

Anonymous User → View Products

Customer → Create Orders

Manager → Manage Products

Admin → Manage Everything

DRF provides authentication and permission mechanisms that help developers implement these rules.

Pagination and Filtering

Imagine an API contains 100,000 products.

You probably don't want to return all of them in a single response.

DRF provides tools for things like:

Pagination
Filtering
Searching
Ordering

These features become extremely useful as applications grow.

5. Browsable API

One of DRF's most useful development features is its Browsable API.

Instead of testing every endpoint only through tools such as Postman, you can interact with your API directly through a web interface.

For someone learning API development, this can make understanding and testing APIs much easier.

Is Django REST Framework Still Worth Learning?

The answer depends on your goals.

If you want to work with Python and web development, Django is a strong framework to learn.

And if you want to build APIs using Django,** Django REST Framework is one of the most important technologies in the Django ecosystem**.

But you don't need to learn every feature immediately.

A reasonable learning path could be:

Python
↓
Web Fundamentals
↓
Django Fundamentals
↓
Models & ORM
↓
Authentication
↓
Django REST Framework
↓
Serializers
↓
API Views / ViewSets
↓
Permissions
↓
Authentication
↓
Filtering & Pagination
↓
Testing & Deployment

Should You Learn Django or Django REST Framework?

This isn't really an either/or decision.

If you're starting with Django, learn the Django fundamentals first.

Understand:

How Django works
URLs
Views
Models
ORM
Migrations
Authentication
Applications

Then move into Django REST Framework.

Once you understand the fundamentals, DRF becomes much easier to understand because you are building APIs on top of concepts you already know.

Final Thoughts

Django is a powerful Python web framework designed to make building web applications easier, faster, and more structured.

Django REST Framework extends Django with powerful tools for building REST APIs.

Together, they can be used to build complete backend systems for:

Web applications
Mobile applications
SaaS platforms
E-commerce systems
Dashboards
Business applications
And many other types of software.

So,** should you learn them?**

If you're interested in Python and web development, Django is definitely worth considering.

And if your goal is to build APIs with Django, learning Django REST Framework is a natural next step.

The important thing isn't simply learning a framework.

It's understanding how web applications, APIs, databases, authentication, and backend systems actually work.

And Django + DRF can be a very good way to learn and build those systems.