<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by WambuiCecilia on Medium]]></title>
        <description><![CDATA[Stories by WambuiCecilia on Medium]]></description>
        <link>https://medium.com/@wambuicecilia36?source=rss-7dca8181154e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*CufpEjgF8Ty14ip-</url>
            <title>Stories by WambuiCecilia on Medium</title>
            <link>https://medium.com/@wambuicecilia36?source=rss-7dca8181154e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 07:26:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@wambuicecilia36/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Django Project vs App: What’s the Difference?]]></title>
            <link>https://medium.com/@wambuicecilia36/django-project-vs-app-whats-the-difference-3b82d74e97f8?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b82d74e97f8</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Sat, 12 Sep 2026 13:57:46 GMT</pubDate>
            <atom:updated>2026-09-12T13:57:46.703Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5WX4sKEZBfac0Li0BY6zYw.png" /></figure><p>When I first started working with Django, one thing that took me a while to understand was the difference between a <strong>Django project</strong> and a <strong>Django app</strong>. You create a project. Then you create an app. Both contain Python files. Both have their own folders.</p><p>So let’s make it practical. We’ll build a small rental platform and use it to understand what a Django project and a Django app actually are.</p><h3>Quick Explanation</h3><p>A <strong>Django project</strong> is the overall website or system. A <strong>Django app</strong> is a specific piece of functionality within that project. Imagine we’re building a rental platform called <strong>Rentals Project</strong>.</p><p>It could have:</p><p>Rentals Project<br>│<br>├── rentals<br>├── accounts<br>├── payments<br>└── reviews</p><p>Each of those can be a Django app. The <strong>project brings everything together</strong>, while the <strong>apps handle individual functionality</strong>. That’s the basic idea. Now let’s see what that actually looks like in code.</p><h3>Creating the Django project</h3><p>Set up your folder, activate your virtual environment, install Django, and run:</p><pre>django-admin startproject rentalsproject .</pre><p>Don’t skip that dot at the end, it tells Django to build everything in your current folder instead of adding an extra layer of nesting you don’t need.</p><p>Once it runs, you’ll see this show up:</p><p>project-vs-app/<br>├── manage.py<br>└── rentalsproject/<br> ├── __init__.py<br> ├── settings.py<br> ├── urls.py<br> ├── asgi.py<br> └── wsgi.py</p><p>At this point, you have a working Django project, but nothing about rentals yet. It’s just the shell.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5sFY-CpGzAyvL2rNJDbUXg.png" /></figure><h3>Understanding the project structure</h3><p>When you’re new to Django, this structure can look like a collection of files you’re expected to memorize. You don’t need to. Let’s go through what each one is actually doing.</p><h3>manage.py</h3><p>manage.py gives us a command-line interface for interacting with our Django project. For example, we can start the development server:</p><pre>python manage.py runserver</pre><p>Create database migrations:</p><pre>python manage.py makemigrations</pre><p>And apply them:</p><pre>python manage.py migrate</pre><h3>__init__.py</h3><p>This file marks the directory as a Python package and allows Python to treat the directory as part of the package structure. You normally don’t need to put anything in it.</p><h3>settings.py</h3><p>It contains the project’s configuration. This is where we’ll configure things such as:</p><ul><li>installed apps</li><li>database settings</li><li>middleware</li><li>templates</li><li>static files</li><li>security settings</li><li>language and timezone</li></ul><p>For example, once we create our rentals app, we’ll tell Django about it through INSTALLED_APPS:</p><pre>INSTALLED_APPS = [<br>    &quot;django.contrib.admin&quot;,<br>    &quot;django.contrib.auth&quot;,<br>    &quot;django.contrib.contenttypes&quot;,<br>    &quot;django.contrib.sessions&quot;,<br>    &quot;django.contrib.messages&quot;,<br>    &quot;django.contrib.staticfiles&quot;,<br>    &quot;rentals_app&quot;,<br>]</pre><p>You’re essentially telling Django: “These are the applications that belong to this project.” Think of settings.py as the <strong>control room of the project</strong>. A lot of decisions about how the project behaves are configured here.</p><h3>urls.py</h3><p>This is where we define the project’s URL configuration.</p><p>If someone visits: /rentals/, /accounts/, /payments/. Django needs to know where those requests should go. The project’s urls.py can connect each section of the website to the appropriate app.</p><p>For example, you’d eventually add something like this:</p><pre>from django.urls import include, path<br>urlpatterns = [<br>    path(&quot;rentals/&quot;, include(&quot;rentals_app.urls&quot;)),<br>]</pre><p>This tells Django that URLs beginning with /rentals/ should be handled by the URL configuration inside the rentals app. The project doesn’t need to contain every URL in the entire application. It can simply connect the different parts of the website to their respective apps.</p><p>From thestartproject, it still looks exactly like Django set it up, a comment block explaining how to include another URLconf, and just the default path to the admin site that allows you to interact with the admin panel:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ztKvDMiBMqb_S04GcdkgQw.png" /></figure><h3>asgi.py</h3><p>It is the entry point for running Django with ASGI (Asynchronous Server Gateway Interface) compatible servers. You’ll encounter it more when you start working with deployment or asynchronous features.</p><h3>wsgi.py</h3><p>It serves a similar purpose, but for <strong>WSGI</strong> (Web Server Gateway Interface). It provides an entry point for WSGI-compatible web servers to communicate with your Django application. You’ll usually encounter this when you start learning about deploying Django applications.</p><h3>Creating the rentals app</h3><p>From the same project folder, run:</p><pre>python manage.py startapp rentals_app</pre><p>And just like that, a new folder shows up next to your project folder:</p><p>project-vs-app/<br>├── manage.py<br>├── rentalsproject/<br>│ └── …<br>└── rentals_app/<br> ├── admin.py<br> ├── apps.py<br> ├── migrations/<br> ├── models.py<br> ├── tests.py<br> └── views.py</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r3e7SRf4wjt1WE_TN_5mHQ.png" /></figure><h3>Understanding the rentals app structure</h3><h3>__init__.py</h3><p>Just like the one inside the project, this is part of Python’s package structure. You normally don’t need to modify it.</p><h3>admin.py</h3><p>This is where we can register and configure our models for Django’s admin interface. Suppose our rental application has a Property model:</p><pre>class Property(models.Model):<br>    title = models.CharField(max_length=200)<br>    location = models.CharField(max_length=200)<br>    price = models.DecimalField(max_digits=10, decimal_places=2)</pre><p>We can register it in admin.py:</p><pre>from django.contrib import admin<br>from .models import Property<br>admin.site.register(Property)</pre><p>Now an administrator can manage properties through Django’s admin interface instead of interacting directly with the database.</p><h3>apps.py</h3><p>This file contains configuration for the app. Django creates:</p><pre>from django.apps import AppConfig<br>class RentalsAppConfig(AppConfig):<br>   name = &#39;rentals_app&#39;</pre><p>This tells Django the name of the app. You won’t usually need to modify this file when building a simple application, but it becomes useful when you need app specific configuration or features such as signals.</p><h3>migrations/</h3><p>This is a folder rather than a single Python file. Django uses migrations to keep track of changes to your database structure. For example, if we create this model:</p><pre>class Property(models.Model):<br>    title = models.CharField(max_length=200)<br>    location = models.CharField(max_length=200)<br>    price = models.DecimalField(max_digits=10, decimal_places=2)</pre><p>we can run:</p><pre>python manage.py makemigrations</pre><p>Django will generate a migration such as:</p><p>rentals_app/<br>└── migrations/<br> └── 0001_initial.py</p><p>That migration records the database changes Django needs to make. We then apply those changes with:</p><pre>python manage.py migrate</pre><h3>models.py</h3><p>This is where we define the data our application needs. For our rental platform, we might create a Property model:</p><pre>from django.db import models<br>class Property(models.Model):<br>    title = models.CharField(max_length=200)<br>    location = models.CharField(max_length=200)<br>    price = models.DecimalField(max_digits=10, decimal_places=2)</pre><p>Instead of manually creating database tables and writing SQL for every operation, Django lets us define our data using Python classes. Django’s ORM(Object Relational Mapper) then maps those models to database tables. If our application needs to store property names, locations, prices, descriptions and availability, we’d define that structure through models.</p><h3>tests.py</h3><p>This is where we can write automated tests for our application. For example, we might test whether:</p><ul><li>a property can be created correctly</li><li>invalid data is rejected</li><li>a rental listing appears correctly</li><li>a view returns the expected response</li></ul><h3>views.py</h3><p>A view handles a request and determines what response should be returned. For example, if someone visits: /rentals/</p><p>we might have:</p><pre>from django.http import HttpResponse<br>def property_list(request):<br>    return HttpResponse(&quot;Here are our available properties.&quot;)</pre><p>The view receives the request:</p><pre>def property_list(request):</pre><p>and returns a response:</p><pre>return HttpResponse(&quot;Here are our available properties.&quot;)</pre><p>Later, instead of returning simple text, the view could retrieve properties from the database and render them in an HTML template.</p><p>The basic flow looks like this:</p><p>Browser → URL → View → Model/Database → Response</p><h3>Tell Django the app actually exists</h3><p>Creating the app isn’t enough on its own, you also have to register it. Open settings.py, scroll to INSTALLED_APPS, and add it to the list:</p><pre>INSTALLED_APPS = [<br>    &quot;django.contrib.admin&quot;,<br>    &quot;django.contrib.auth&quot;,<br>    &quot;django.contrib.contenttypes&quot;,<br>    &quot;django.contrib.sessions&quot;,<br>    &quot;django.contrib.messages&quot;,<br>    &quot;django.contrib.staticfiles&quot;,<br>    &quot;rentals_app&quot;,<br>]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FfqekZSAfK3ueZWNDbC3fQ.png" /></figure><p>If you forget this part, nothing crashes, nothing warns you, your app just quietly doesn’t exist as far as Django’s concerned.</p><h3>Check that it actually works</h3><p>Run:</p><pre>python manage.py runserver</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SL_1VIyz9amTq18FSDnTEA.png" /></figure><p>You haven’t written a single line of rental specific code that a visitor would actually use, and yet the site runs. That’s really the whole point of separating the two, the project gives you a working foundation, and the apps are where you build on top of it, one piece at a time.</p><h3>Why not put everything in one app?</h3><p>You could technically stuff everything, rentals, payments, accounts, reviews, into one giant app. Plenty of people do, especially early on. But the moment your project grows, that one app becomes a maze. Splitting things up means when you need to fix something in payments, you go straight to the payments folder.</p><h3>Conclusion</h3><p>To conclude; Project = the house. App = a room inside it. You can keep adding rooms, accounts, payments, reviews, without ever tearing down the house to do it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b82d74e97f8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The One Line in My Django Form That Took Me Way Too Long to Understand]]></title>
            <link>https://medium.com/@wambuicecilia36/the-one-line-in-my-django-form-that-took-me-way-too-long-to-understand-bf194b4aa565?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf194b4aa565</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django-forms]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 10:54:10 GMT</pubDate>
            <atom:updated>2026-08-11T10:54:10.532Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TkEnn1ZwtUgsznGmTiL0QQ.png" /></figure><p>For a while, `commit=False` was just something I typed because a tutorial told me to. I knew it belonged next to `form.save()`. I knew something would break if I removed it. But I could not have explained what it actually did. That changed when I ran into an `IntegrityError` while building my Django blog application.</p><p>Here is the line that caused me so much confusion:</p><pre>post = form.save(commit=False)</pre><pre>@login_required<br>def create_post(request):<br>    if request.method == &#39;POST&#39;:<br>        form = BlogPostForm(request.POST)<br>        if form.is_valid():<br>            post = form.save(commit=False)<br>            post.author = request.user<br>            post.save()<br>            messages.success(request, &#39;Your post has been created!&#39;)<br>            return redirect(&#39;post_detail&#39;, post_id=post.id)<br>    else:<br>        form = BlogPostForm()<br><br>    return render(request, &#39;blog/post_form.html&#39;, {&#39;form&#39;: form})<br><br></pre><p>If you have written a few Django views, you have probably seen something similar. There is also a good chance you first used this pattern by copying it from a tutorial, watching it work, and moving on. That is exactly what I did.</p><h3>What I thought was happening</h3><p>My mental model was that `commit=False` paused the save. I imagined Django beginning a database operation, stopping halfway through, and waiting for this line:</p><pre>post.save()</pre><p>In my head, the second `.save()` resumed the first save and finally allowed it to finish. That explanation felt reasonable at the time. It was also wrong. Once I understood what was really happening, several other parts of Django forms became easier to understand.</p><h3>What `form.save()` actually does</h3><p>A `ModelForm` connects a form to a Django model. After the form has been validated, Django has a model instance containing the cleaned data from the form.</p><p>When you call:</p><pre>post = form.save()</pre><p>Django saves that model instance to the database and returns it. The default value of `commit` is `True`, which means the database save happens immediately.</p><p>When you call:</p><pre>post = form.save(commit=False)</pre><p>Django returns the model instance without saving it to the database. It does not pause a save that is already in progress. It simply gives you the object before the database write takes place. <a href="https://docs.djangoproject.com/en/6.0/topics/forms/modelforms/">Django’s documentation </a>describes this as returning an unsaved model instance that you can modify before saving manually.</p><p>For example:</p><pre>post = form.save(commit=False)  # An unsaved BlogPost object<br>post.author = request.user       # Add data from the request<br>post.save()                      # Write the completed object to the database</pre><p>At the point where `commit=False` returns, `post` is an ordinary Python object. It is a real `BlogPost` instance, but it is not yet a row in the database. There is no unfinished database operation waiting in the background.</p><h3>Why I needed it in my blog</h3><p>My `BlogPostForm` contains these fields:</p><pre>from django import forms<br>from .models import BlogPost<br><br>class BlogPostForm(forms.ModelForm):<br>    class Meta:<br>        model = BlogPost<br>        fields = [&#39;title&#39;, &#39;content&#39;, &#39;is_published&#39;]<br>        widgets = {<br>            &#39;content&#39;: forms.Textarea(attrs={<br>                &#39;rows&#39;: 10,<br>                &#39;placeholder&#39;: &#39;Write your post here...&#39;<br>            }),<br>        }<br>        labels = {<br>            &#39;title&#39;: &#39;Post Title&#39;,<br>            &#39;content&#39;: &#39;Post Content&#39;,<br>            &#39;is_published&#39;: &#39;Publish Immediately&#39;,<br>        }<br>        help_texts = {<br>            &#39;title&#39;: &#39;Enter a catchy title for your post.&#39;,<br>            &#39;is_published&#39;: &#39;Check this to publish the post immediately.&#39;,<br>        }<br><br>    def clean_title(self):<br>        title = self.cleaned_data.get(&#39;title&#39;)<br>        if len(title) &lt; 10:<br>            raise forms.ValidationError(&quot;Title must be at least 10 characters long.&quot;)<br>        return title</pre><p>Notice what is missing:</p><pre>author</pre><p>That omission is intentional. I do not want a text field on the page where someone can type the name of the author. If a user is logged in, the author should automatically be the account that created the post.</p><p>That information comes from the request:</p><pre>post.author = request.user</pre><pre>@login_required<br>def create_post(request):<br>    if request.method == &#39;POST&#39;:<br>        form = BlogPostForm(request.POST)<br>        if form.is_valid():<br>            post = form.save(commit=False)<br>            post.author = request.user<br>            post.save()<br>            messages.success(request, &#39;Your post has been created!&#39;)<br>            return redirect(&#39;post_detail&#39;, post_id=post.id)<br>    else:<br>        form = BlogPostForm()<br><br>    return render(request, &#39;blog/post_form.html&#39;, {&#39;form&#39;: form})</pre><p>It does not come from the submitted form. My model has an author field that points to the logged-in user:</p><pre>from django.db import models<br>from django.contrib.auth.models import User<br><br>class BlogPost(models.Model):<br><br>  title = models.CharField(max_length=200)<br>  content = models.TextField()<br>  published_date = models.DateTimeField(auto_now_add=True)<br>  is_published = models.BooleanField(default=False)<br>  author = models.ForeignKey(User, on_delete=models.CASCADE)<br><br>  def __str__(self):<br>    return self.title</pre><p>Because `author` is a required foreign key, Django cannot save a blog post without an author.</p><p>If I do this:</p><pre>if form.is_valid():<br>    post = form.save()</pre><p>Django tries to save the object before I have assigned its author. The database then rejects the insert because the required `author_id` value is missing. That is where the `IntegrityError` came from in my project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FHkYzn1vd-hDnKU3NbVXCw.png" /></figure><h3>The fix</h3><p>`commit=False` gives me a chance to add the missing value before Django writes anything to the database:</p><pre>if form.is_valid():<br>    post = form.save(commit=False)<br>    post.author = request.user<br>    post.save()</pre><p>The sequence is now:</p><p>1. The user submits the title, content, and publication status.</p><p>2. Django validates the form.</p><p>3. Django creates an unsaved `BlogPost` instance from that data.</p><p>4. I assign the author from `request.user`.</p><p>5. Django saves the completed object.</p><p>The form handles the data the user is allowed to submit. The view handles the data that should come from the application itself. That separation is important. The user should be able to write the content of a post, but they should not be able to decide which account gets credited as its author.</p><h3>Conclusion</h3><p>The form was not broken. It had done exactly what I told it to do. It collected the title, content, and publication status, but it knew nothing about the person creating the post.</p><p>That part came from the view:</p><pre>post = form.save(commit=False)<br>post.author = request.user<br>post.save()</pre><p>`commit=False` gave me a chance to add the author before the post was saved. It was not pausing a save that had already started. It was simply returning the BlogPost object while it was still unsaved. That is the part I had missed.</p><p>I had been using the line correctly without really understanding it. Now, when I see `form.save(commit=False)`, I know what it means: Django has prepared the object, but I still need to add something before saving it. In my case, that something was the logged-in user. Once I understood that, the IntegrityError finally made sense.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf194b4aa565" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Django Errors Every Beginner Runs Into and How to Fix Them]]></title>
            <link>https://medium.com/@wambuicecilia36/the-django-errors-every-beginner-runs-into-and-how-to-fix-them-649df1327542?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/649df1327542</guid>
            <category><![CDATA[debugging]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 04:03:45 GMT</pubDate>
            <atom:updated>2026-08-04T04:28:23.342Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SB8khxjKCuQmYuBFRioBLw.png" /></figure><p>When you’re learning Django, the hardest part usually isn’t writing the code. It’s getting all the pieces to talk to each other. Apps, URLs, views, templates, models, migrations, forms, static files, and the admin all make sense on their own. The confusing errors usually happen in the spaces between them.</p><p>I ran into this while building a small recipe app called RecipeBox. The app itself was simple, but I decided to work through the setup properly instead of skipping over the mistakes. That turned into a useful list of beginner Django errors, and, more importantly, a better understanding of what those errors were actually trying to tell me.</p><p>By the end, I realized most of the problems came down to the same thing: two parts of the project were out of sync. The app existed, but Django didn’t know about it. The URL existed, but the project didn’t include it. The model changed, but the database hadn’t been updated.</p><p>Django’s error messages can look intimidating at first, but they are usually pointing at the exact disagreement. You just have to slow down enough to read them. Here are the errors I ran into while building RecipeBox, what caused them, and how I fixed each one.</p><h3>1. makemigrations says “No changes detected”</h3><p>I started by creating a simple Recipe model in my app’s <em>models.py</em> file:</p><pre>from django.db import models<br><br>class Recipe(models.Model):<br>    name = models.CharField(max_length=200)<br>    description = models.TextField()<br>    prep_time = models.PositiveIntegerField()<br><br>    def __str__(self):<br>        return self.name</pre><p>With the code saved, I went to my terminal and ran the command to generate the migration:</p><pre>python manage.py makemigrations</pre><p>Instead of creating a new migration file, Django came back with a blank statement:</p><pre>No changes detected</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PEr9Rb-VdupNxWYDtkBf6w.png" /></figure><p>This threw me off for a second. I had just written the model and saved the file. My first instinct was that I must have mistyped a field name or messed up the class syntax, causing Django to silently ignore the whole thing.</p><p>But Django wasn’t ignoring my code because of a typo. It was ignoring it because it didn’t even know the app existed.</p><p><strong>The issue:</strong> I had created the recipes app folder, but I hadn’t registered it in the project’s <em>settings.py</em> file. Because it wasn’t listed in INSTALLED_APPS, Django’s migration engine didn’t bother looking inside the folder for models to track.</p><p>To fix it, I opened <em>settings.py</em> and added “recipes” to the list:</p><pre>INSTALLED_APPS = [<br>    &quot;django.contrib.admin&quot;,<br>    &quot;django.contrib.auth&quot;,<br>    &quot;django.contrib.contenttypes&quot;,<br>    &quot;django.contrib.sessions&quot;,<br>    &quot;django.contrib.messages&quot;,<br>    &quot;django.contrib.staticfiles&quot;,<br>    &quot;recipes&quot;,<br>]</pre><p>Once registered, I ran the command again:</p><pre>python manage.py makemigrations</pre><p>This time, Django successfully detected the model and created the file:</p><pre>Migrations for &#39;recipes&#39;:<br>    recipes/migrations/0001_initial.py<br>    + Create model Recipe</pre><p><strong>The takeaway: </strong>When Django says “No changes detected,” it doesn’t always mean your model syntax is wrong. Usually, it means Django doesn’t even know it’s supposed to be looking at your app. Whenever you hit this, INSTALLED_APPS is the very first place you should check.</p><h3>2. My view existed. My URL existed. The homepage still didn’t load.</h3><p>After getting the model and migrations working, I moved on to something simpler: showing a homepage.</p><p>In <em>recipes/views.py</em>, I created a basic view:</p><pre>from django.http import HttpResponse<br><br>def home(request):<br>    return HttpResponse(&quot;&lt;h1&gt;Welcome to RecipeBox&lt;/h1&gt;&quot;)</pre><p>Then I created <em>recipes/urls.py</em>:</p><pre>from django.urls import path<br>from . import views<br><br>urlpatterns = [<br>    path(&quot;&quot;, views.home, name=&quot;home&quot;),<br>]</pre><p>Everything looked correct. I had a view, and I had a URL pointing to it.</p><p>But when I opened the homepage, I still saw Django’s default welcome page instead of my <strong>“Welcome to RecipeBox”</strong> message.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Zg5QaOmpudZUiIOwHbLXw.png" /></figure><p>The missing piece was the project level <em>urls.py</em>. Creating <em>recipes/urls.py</em> does not automatically connect it to the project. Django needs to be told to include the app’s URL configuration.</p><p>In the main <em>project’s urls.py</em>, I added:</p><pre>from django.contrib import admin<br>from django.urls import include, path<br><br>urlpatterns = [<br>    path(&quot;admin/&quot;, admin.site.urls),<br>    path(&quot;&quot;, include(&quot;recipes.urls&quot;)),<br>]</pre><p>After that, the homepage finally displayed <strong>“Welcome to RecipeBox”</strong></p><p>The useful way to think about this is:</p><p><em>project/urls.py → recipes/urls.py → recipes/views.py</em></p><p>The project receives the request first. It then passes the request to the app’s URL configuration, which points to the correct view. If the project does not include the app’s URLs, Django never reaches the view, even if the view and the app-level URL pattern are correct.</p><p><strong>The takeaway: </strong>Creating an app level <em>urls.py</em> is only half the setup. You must also include it in the project’s main <em>urls.py</em>.</p><h3>3. A 404 for a URL that genuinely doesn’t exist</h3><p>I visited /about/ in the browser. I had not built an /about/ view yet, so Django returned a 404 page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g97pI-5y3nxmq9aqFLpYfg.png" /></figure><p>My first reaction was to go looking for what had broken. But nothing had broken.</p><p>At that point, my entire URL configuration looked like this:</p><pre>path(&quot;&quot;, views.home, name=&quot;home&quot;)</pre><p>There was no route for /about/, so Django had nothing to match the request to. It was not malfunctioning, it was accurately reporting that no URL pattern existed for that path.</p><p><strong>The takeaway:</strong> A 404 is not automatically a problem to solve. Sometimes it simply means you requested a page you never built. Before debugging, check whether the route is supposed to exist in the first place.</p><h3>4. TemplateDoesNotExist</h3><p>I moved the homepage HTML out of the view and into a template:</p><pre>from django.shortcuts import render<br><br>def home(request):<br>    return render(request, &quot;recipes/home.html&quot;)</pre><p>When I loaded the page, Django responded with:</p><pre>TemplateDoesNotExist at /<br><br>recipes/home.html</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kFnfk_d-AJjCGtwROD2dIg.png" /></figure><p>Easy to skim past that path and just think “template broke.” But that line is the fix, Django tells you exactly where it looked and didn’t find anything.</p><p>I hadn’t created the folder structure Django expects:</p><pre>recipes/<br>└── templates/<br>    └── recipes/<br>        └── home.html</pre><p>Once I created that structure and added actual HTML inside home.html, the page rendered correctly.</p><p><strong>The takeaway: </strong>When Django says TemplateDoesNotExist, do not just re-check your render() call. Read the path in the error message, it tells you precisely where Django searched, which is usually all you need to find the fix.</p><h3>5. NoReverseMatch</h3><p>Next, I added a detail page for individual recipes:</p><pre>path(&quot;recipes/&lt;int:id&gt;/&quot;, views.recipe_detail, name=&quot;recipe_detail&quot;)</pre><p>Then I linked to it from my homepage template:</p><pre>&lt;a href=&quot;{% url &#39;recipe&#39; 1 %}&quot;&gt;View Recipe&lt;/a&gt;</pre><p>Instead of rendering the page, Django threw this error:</p><pre>NoReverseMatch: Reverse for &#39;recipe&#39; not found. &#39;recipe&#39; is not a valid view function or pattern name.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BydH-stagJ-7_4vHUrIgRA.png" /></figure><p>At first, I thought there was something wrong with the URL pattern itself. But the pattern was fine. The problem was much simpler. In my template, I was trying to reverse a URL named “recipe”:</p><pre>{% url &#39;recipe&#39; 1 %}</pre><p>But in urls.py, I had registered it as:</p><pre>name=&quot;recipe_detail&quot;</pre><p>The {% url %} template tag looks for the value of the name argument exactly as you defined it. It doesn’t use the view function name or try to guess what you meant.</p><p>Changing the template to match the URL name fixed the issue:</p><pre>&lt;a href=&quot;{% url &#39;recipe_detail&#39; 1 %}&quot;&gt;View Recipe&lt;/a&gt;</pre><p>The page loaded as expected.</p><p><strong>The takeaway:</strong> If you run into a NoReverseMatch error, compare the name inside your {% url %} tag with the name= value in your URL pattern. Even a one-character difference is enough to trigger the error.</p><h3>6. CSRF verification failed</h3><p>I added a simple form for creating a new recipe:</p><pre>&lt;form method=&quot;post&quot;&gt;<br>    &lt;input<br>        type=&quot;text&quot;<br>        name=&quot;name&quot;<br>        placeholder=&quot;Recipe name&quot;<br>    &gt;<br>    &lt;button type=&quot;submit&quot;&gt;<br>        Save Recipe<br>    &lt;/button&gt;<br>&lt;/form&gt;<br><br></pre><p>The form displayed without any issues. However, when I submitted it, Django returned:</p><pre>Forbidden (403)<br><br>CSRF verification failed. Request aborted.</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0aeHHsqkUqEskLzNZUHyiA.png" /></figure><p>This wasn’t a bug, it was Django protecting the app. Any POST request must include a CSRF token to prevent cross-site request forgery attacks. I had simply forgotten to add it.</p><p>I updated the form to include the token:</p><pre>&lt;form method=&quot;post&quot;&gt;<br>    {% csrf_token %}<br><br>    &lt;input<br>        type=&quot;text&quot;<br>        name=&quot;name&quot;<br>        placeholder=&quot;Recipe name&quot;<br>    &gt;<br><br>    &lt;button type=&quot;submit&quot;&gt;<br>        Save Recipe<br>    &lt;/button&gt;<br>&lt;/form&gt;</pre><p>After resubmitting, the form worked correctly.</p><p><strong>The takeaway:</strong> Every Django form that uses method=”post” must include {% csrf_token %} inside the &lt;form&gt; tag. It’s easy to forget on the first try, but once it becomes a habit, it rarely causes problems again.</p><h3>7. My model changed, but the database didn’t</h3><p>This was the error that finally made migrations click for me.</p><p>I added a new field to the Recipe model:</p><pre>servings = models.PositiveIntegerField(default=1)</pre><p>Then I tried to create a recipe using that field. Django returned:</p><pre>sqlite3.OperationalError: table recipes_recipe has no column named servings</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mcRG3R6P-pE-raWPoOEDeA.png" /></figure><p>The message described the problem exactly: my model included a servings field, but the corresponding database table did not.</p><p>I had updated models.py, but I had not applied that change to the database. In Django, those are separate steps.</p><p>I fixed it by running:</p><pre>python manage.py makemigrations<br>python manage.py migrate</pre><p><em>makemigrations</em> created a migration file containing the instructions for the change. migrate then applied those instructions to the database.</p><p>After both commands were completed, the servings column existed and I could save the recipe.</p><p><strong>The takeaway:</strong> Changing a model does not automatically update the database. <em>makemigrations</em> creates the migration files; migrate applies them. If your database complains about a missing table or column after a model change, check whether you completed both steps.</p><h3>8. My CSS returned a 404</h3><p>I loaded the static files tag and linked my stylesheet:</p><pre>{% load static %}<br><br>&lt;link rel=&quot;stylesheet&quot; href=&quot;{% static &#39;css/styles.css&#39; %}&quot;&gt;</pre><p>The page loaded fine, but none of my styling was applied. There was no error page and no traceback, which made it harder to know where to look.</p><p>The Network tab in the browser dev tools showed the actual problem: the CSS request itself was returning a 404.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oxLdjmu1THByNfsCJ9TAoQ.png" /></figure><p>I had written styles.css in the template, but the file on disk was named style.css. After fixing the filename and refreshing, the styling appeared.</p><p>It is worth separating this from the 404 in error #3. That one happened because no URL pattern matched the requested page. This one happened because the browser requested a static file that wasn’t at the path it expected.</p><p>Same status code, different layer of the app, and knowing which layer you’re dealing with tells you where to start looking.</p><p><strong>The takeaway:</strong> If a page renders but looks unstyled, check the Network tab before touching your CSS. A 404 on the stylesheet usually points to a filename or path mismatch rather than a problem with the styles themselves.</p><h3>9. My model didn’t show up in Django Admin</h3><p>This one had no error page at all, which was almost more disorienting. I had a working Recipe model, and data was saving fine. But when I opened the Django admin dashboard, there was no “Recipes” section. No red text, no traceback, just an empty spot where I expected to see my model.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZlKPygk2MTHKrTmHakQyhw.png" /></figure><p>The reason: creating a model does not automatically register it with the admin site. Those are two separate actions.</p><p>In <em>admin.py</em>, I added:</p><pre>from django.contrib import admin<br>from .models import Recipe<br><br>admin.site.register(Recipe)</pre><p>After refreshing the admin dashboard, “Recipes” appeared, fully manageable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xIL0L-PW946r5RH4kxDC2w.png" /></figure><p><strong>The takeaway:</strong> A model existing and a model being visible in the admin are unrelated facts. If you want to manage a model through Django admin, you have to explicitly register it, Django won’t infer that from the model just existing.</p><h3>What building RecipeBox actually taught me</h3><p>None of these nine errors were individually hard. Looking back, every single one came down to the same shape of problem: two parts of the app that were supposed to be connected, weren’t.</p><ul><li>The app existed, but wasn’t registered.</li><li>The app had URLs, but the project didn’t include them.</li><li>The template existed, but not where Django was looking for it.</li><li>The link pointed to a name that didn’t match the actual URL name.</li><li>The form posted data without the token Django requires.</li><li>The model changed, but the database was never told.</li><li>The static file was referenced under the wrong name.</li><li>The model worked, but the admin was never told it existed.</li></ul><p>Once I stopped treating Django’s error pages as obstacles to clear as fast as possible, and started reading them as Django telling me exactly which two things had stopped agreeing with each other, debugging got a lot less stressful. TemplateDoesNotExist tells you the path it searched. NoReverseMatch tells you the name it couldn’t resolve. A database error naming a missing column is pointing you straight at your migrations.</p><p>The question worth asking every time isn’t “how do I make this error go away.” It’s: <strong>which two parts of my app is Django telling me to go check?</strong></p><p>Once that mental pivot becomes automatic, Django stops feeling like an unpredictable black box and starts feeling like a logical system you can comfortably reason through.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=649df1327542" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[makemigrations vs migrate in Django: What’s the Difference?]]></title>
            <link>https://medium.com/@wambuicecilia36/makemigrations-vs-migrate-in-django-whats-the-difference-4121055699c0?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/4121055699c0</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[django]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 09:32:30 GMT</pubDate>
            <atom:updated>2026-07-24T09:32:30.717Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8ctjNpkkpMMHRqJl06U1Ww.png" /></figure><p>If you’ve ever edited your models.py, stared at your database, and wondered why nothing actually changed, don’t worry, almost everyone trips over Django migrations when starting out. The confusion usually comes down to one thing: <strong>Django doesn’t touch your database when you edit Python code.</strong> Changing a model is just drafting an idea. To actually update the database, you have to run two separate commands, in a specific order.</p><p>Here is what’s actually happening under the hood.</p><h3>The Mental Model</h3><p>Think of database changes in two stages: planning and executing.</p><ul><li><strong>models.py:</strong> Your blueprint. It defines what you <em>want</em> your data to look like in Python.</li><li><strong>makemigrations:</strong> The planner. It inspects models.py, compares it against your past migrations, and generates a new instruction file (a migration script). It does not touch your database.</li><li><strong>migrate:</strong> The executor. It reads those instruction files and actually runs the SQL to create or update your database tables.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TnRWXaL5BW5uWnuq53pD0w.png" /></figure><h3>A Quick Code Example</h3><p>To see this in action, we’ll use the Task model from our<a href="https://youtu.be/SGj1lTigkAg"> <strong>Django Beginner Tutorial on YouTube</strong></a></p><pre>from django.db import models<br><br>class Task(models.Model):<br><br>  title = models.CharField(max_length=200)<br>  description = models.TextField()<br>  completed = models.BooleanField(default=False)<br>  created_at = models.DateTimeField(auto_now_add=True)<br>  <br>  def __str__(self):<br>    return self.title</pre><p>Editing this file is totally safe. You can add, tweak, or delete fields all day long, nothing breaks because Python hasn’t talked to your database yet.</p><h3>Step 1: makemigrations (Write the Plan)</h3><p>When you’re ready to lock in your schema changes, run:</p><pre>python manage.py makemigrations</pre><p>Django checks your app’s migrations/ folder, notices your new Task model, and creates a file named something like 0001_initial.py.</p><p>If you open that file, you’ll see Python code that describes the database operations needed to build that table.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wIQtRsA99W9EvTfQxsXahg.png" /></figure><h3>Why doesn’t Django just update the database automatically?</h3><p>Keeping design separate from execution saves you from accidental disasters:</p><ol><li><strong>Sanity checks:</strong> You can look at the migration file <em>before</em> touching real data to ensure Django interpreted your changes correctly.</li><li><strong>Version control:</strong> Migration files live in Git alongside your code, meaning your teammates get the exact same database setup when they pull down your branch.</li><li><strong>Custom data fixes:</strong> If you need to transform or back up data before dropping a column, you can write custom logic inside the migration file first.</li></ol><h3>Step 2: migrate (Run the Plan)</h3><p>Once the migration file looks good, run:</p><pre>python manage.py migrate</pre><p>Django checks a special hidden table in your database called django_migrations. It looks for any migration files in your project that haven’t been run yet, executes the corresponding SQL (CREATE TABLE, ALTER TABLE, etc.), and checks them off the list.</p><p>Now your database schema matches your models.py.</p><h3>The 2-Step Workflow in Action</h3><p>Let’s add a deadline field to our task model:</p><pre># models.py<br>deadline = models.DateTimeField(null=True, blank=True)</pre><ol><li><strong>Draft it:</strong> Run<em> python manage.py makemigrations</em>.<br>Django creates 0002_add_deadline.py with an AddField instruction.</li><li><strong>Apply it:</strong> Run <em>python manage.py migrate</em>.<br>Django connects to PostgreSQL/SQLite and executes the SQL statement to add the column.</li></ol><h3>Common Beginner Confusions</h3><ul><li><strong>“I ran makemigrations, but my admin panel didn’t change!”</strong> You wrote the plan, but didn’t execute it. Run <em>python manage.py migrate</em>.</li><li><strong>“migrate says ‘No migrations to apply’, but I edited models.py!”</strong> You forgot to generate the plan. Run <em>python manage.py makemigrations</em> first.</li><li><strong>“Why do I have so many migration files?”</strong> Think of them like Git commits for your database schema. They record your project’s database history step-by-step so you can replicate or roll back changes anytime.</li><li><strong>“Django asked me if I renamed a field, what do I do?”</strong> Pay attention to prompts like Did you rename task.due_date to task.deadline? [y/N]. If you hit “No”, Django might delete the old column (and its data) and create a brand new empty one.</li></ul><h3>Practical Habits to Keep Your Database Safe</h3><ul><li><strong>Commit your migrations:</strong> Always check your migrations/ folder into Git. Never .gitignore it.</li><li><strong>Look before you leap:</strong> Skim auto-generated migration files before running migrate, especially in production.</li><li><strong>Deploy together:</strong> Pull your latest code to the server, then run python manage.py migrate as part of your deployment build script.</li></ul><h3>Conclusion</h3><p>Once you get used to this two-step workflow, database migrations stop feeling like a chore and start working like a safety net. You design your models in Python, verify the plan, and apply the changes when you’re ready, no unexpected schema drops and no lost data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4121055699c0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Never Deploy Django Without These 6 Things]]></title>
            <link>https://medium.com/@wambuicecilia36/never-deploy-django-without-these-6-things-62836c9e7940?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/62836c9e7940</guid>
            <category><![CDATA[django]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[django-deployment]]></category>
            <category><![CDATA[render]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 12:21:31 GMT</pubDate>
            <atom:updated>2026-07-08T07:57:20.637Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SDYQ20DixkZi9OD1x76FVA.jpeg" /></figure><p>Deploying a Django app feels great, until something breaks in production.<br>Everything may work locally, but once you deploy, you might run into missing styles, database errors, or an app that won’t start at all. That’s because Django’s default setup is built for development, not production.</p><p>Before you deploy, make sure these six essentials are in place. If you are using <a href="https://render.com/">Render</a>, you also need an account there first, because that is where your app and database will be created and managed.</p><h3>Prefer Watching Instead?</h3><p>If you’d rather see the full deployment process in action, I recorded a step-by-step walkthrough showing how to deploy a Django app to Render. You can watch it here:<a href="https://youtu.be/6x9tUZhbNaY?si=JeCYyFzpHipWlV9b"> https://youtu.be/6x9tUZhbNaY?si=JeCYyFzpHipWlV9b</a></p><h3>1. Gunicorn</h3><p>Django’s built-in runserver command is only for development. It is great for testing and debugging, but it is not meant for real traffic or production use. Gunicorn is the server that actually runs your Django app in production.</p><p>Install it with:</p><pre>pip install gunicorn</pre><p>Then add it to your requirements.txt and start your app with a command like this during deployment on Render:</p><pre>gunicorn project_name.wsgi</pre><p>Django builds the app. Gunicorn serves it.</p><h3>2. WhiteNoise</h3><p>In development, Django can find your static files through STATICFILES_DIRS.<br>In production, that is not enough. WhiteNoise serves the collected static files from STATIC_ROOT, which is why it is so useful when deploying to Render.</p><p>A simple setup looks like this:</p><pre>pip install whitenoise</pre><p>Add the middleware:</p><pre>MIDDLEWARE = [<br>&quot;django.middleware.security.SecurityMiddleware&quot;,<br>&quot;whitenoise.middleware.WhiteNoiseMiddleware&quot;,<br>]</pre><p>Then define your static settings:</p><pre>STATIC_URL = &quot;static/&quot;<br>STATICFILES_DIRS = [BASE_DIR / &quot;static&quot;]<br>STATIC_ROOT = BASE_DIR / &quot;staticfiles&quot;</pre><p>If you are using a newer Django version, you should also configure STORAGES so Django knows how to handle static files properly:</p><pre>STORAGES = {<br>  &quot;default&quot;: {<br>  &quot;BACKEND&quot;: &quot;django.core.files.storage.FileSystemStorage&quot;,<br>},<br>&quot;staticfiles&quot;: {<br>  &quot;BACKEND&quot;: &quot;whitenoise.storage.CompressedManifestStaticFilesStorage&quot;,<br>  },<br>}</pre><p>This matters because STORAGES tells Django which storage backend to use.<br>The staticfiles setting makes WhiteNoise manage your static assets correctly in production, including compression and versioned file names.<br>So the flow is simple: STATICFILES_DIRS holds your source files, collectstatic gathers them into STATIC_ROOT, and WhiteNoise serves them from there in production.</p><p>Finally, collect the files:</p><pre>python manage.py collectstatic</pre><h3>3. psycopg</h3><p>SQLite is fine for development, but production usually needs PostgreSQL.<br>To let Django talk to PostgreSQL, you need psycopg.</p><p>Install it with:</p><pre>pip install psycopg2-binary</pre><p>Without it, Django cannot connect to your production database on Render or any other hosting platform using PostgreSQL.</p><h3>4. dj-database-url</h3><p>Most hosting platforms give you one database connection string.<br>Instead of breaking it apart manually, dj-database-url lets Django read it directly.</p><p>Install it with:</p><pre>pip install dj-database-url</pre><p>Then use it like this in your settings.py:</p><pre>import dj_database_url<br><br>DATABASES = {<br>  &quot;default&quot;: dj_database_url.config()<br>}</pre><p>It keeps your database setup clean and simple, especially when moving between local development and a Render production database.</p><h3>5. python-decouple</h3><p>Never hardcode things like your SECRET_KEY, database password, or API keys in your project.<br>Those should live in environment variables instead.</p><p>python-decouple makes that easy:</p><pre>pip install python-decouple</pre><p>Then use it in your settings.py like this:</p><pre>from decouple import config<br><br><br>SECRET_KEY = config(&quot;SECRET_KEY&quot;)<br>DEBUG = config(&quot;DEBUG&quot;, cast=bool)</pre><p>This keeps sensitive data out of your code and makes deployment safer and easier to manage on Render.</p><h3>6. requirements.txt</h3><p>Your deployment platform starts with a fresh environment.<br>It only knows what to install if you give it a requirements.txt file.</p><p>Generate it with:</p><pre>pip freeze &gt; requirements.txt</pre><p>If you forget to update it after adding packages, your deployment may fail because those packages won’t exist in production.</p><h3>Common mistakes to avoid</h3><p>Before deploying, double-check these:</p><ul><li>DEBUG=True is turned off.</li><li>ALLOWED_HOSTS is set.</li><li>collectstatic has been run.</li><li>Migrations have been applied.</li><li>Secrets are not hardcoded.</li><li>requirements.txt is up to date.</li><li>You have an active Render account before trying to deploy.</li></ul><h3>Quick checklist</h3><ul><li>Gunicorn installed.</li><li>WhiteNoise configured.</li><li>PostgreSQL adapter installed.</li><li>Database URL handled properly.</li><li>Secrets stored safely.</li><li>requirements.txt updated.</li><li>Render account created and ready.</li></ul><h3>Conclusion</h3><p>Deploying Django is not just about uploading code. It is about preparing your app for a production environment where security, performance, and reliability matter.</p><p>If you understand these six things, deployment becomes much smoother and much less stressful. Render makes the hosting part easier, but your Django project still needs to be properly prepared before deployment.</p><p>Thanks for reading, and happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62836c9e7940" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a Free Learning Platform for Developers in 2026 — Meet DevNook]]></title>
            <link>https://medium.com/@wambuicecilia36/i-built-a-free-learning-platform-for-developers-in-2026-meet-devnook-ffe3c330b048?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/ffe3c330b048</guid>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Fri, 27 Feb 2026 07:28:28 GMT</pubDate>
            <atom:updated>2026-02-27T07:28:28.730Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How I went from frustrated developer to building the one-stop learning platform I always wished existed</em></p><p>Here’s something I noticed a while back. Every time I wanted to learn something new as a developer, I’d end up in five different places at once. A YouTube video here, a random article there, a tutorial I bookmarked three weeks ago that I’d never actually read. By the time I’d gathered enough resources to even start, I was already exhausted and I hadn’t learned a thing.</p><p>I didn’t need more content. There’s plenty of that on the internet. What I needed was one place that had everything organized, ready, and easy to get into without the chaos. So I built it.</p><p>DevNook is a free learning platform I created, a modern one-stop space where developers can find everything they need to learn and grow, without jumping between dozens of tabs, tutorials, and half-finished courses. Whether you’re just starting out or filling gaps in what you already know, it’s all in one place, structured and ready for you.</p><h3>What Is DevNook?</h3><p>DevNook is a free knowledge platform built for developers, whether you’ve been coding for years or you’re just figuring out what HTML even means.</p><p>The idea is simple. Instead of sending you off to ten different places, DevNook brings the resources to you. Courses, topics, learning paths, all organized in one place, searchable, and sorted by difficulty so you always know where you stand and where to go next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1tNY7LLMTYYtR9OlX3vDJQ.png" /></figure><h3>The Platform in Detail</h3><h3>Categories: Your Starting Point</h3><p>When you land on DevNook, the first thing you can do is <strong>Explore by Category</strong>. Think of categories as the major knowledge domains, broad areas that contain multiple courses and topics underneath them.</p><p>Whether you’re a total beginner trying to figure out where to start, or an experienced developer looking to fill a specific gap, the categories give you an instant mental map of where to go.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hDbPudHeomnOqwxML8WrMg.png" /></figure><h3>Courses: Structured Learning Paths</h3><p>The Courses section is where learning paths live. It covers everything from <em>JavaScript Essentials</em> to <em>Figma Complete Mastery</em>, there’s a clear path for wherever you are in your journey.</p><p>Each course groups related topics together so you’re not jumping around randomly. You follow a logical progression, topic by topic, skill by skill.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0J446w5dI1D_-CbSWXvRhw.png" /></figure><h3>Topics: The Actual Learning Content</h3><p>Topics are the individual learning units inside each course, with each one being a focused, readable resource, not a 6-hour video you have to scrub through.</p><p>Topics include estimated read times (most are 15–20 minutes), difficulty levels, and are filterable by course. Examples include <em>Template Literals</em>, <em>Object Oriented Programming in JavaScript</em>, <em>Web Storage (localStorage &amp; sessionStorage)</em>, and many more. The goal is focused, distraction-free reading that you can actually finish.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hOzqoAlstqDW2qlKyZWEiQ.png" /></figure><h3>Your Library: Bookmarks That Actually Work</h3><p>One of my favourite features is the <strong>Library</strong>, a personal bookmarks page where you can save any topic for later and come back to it instantly.</p><p>No more losing that article in a sea of browser tabs. You save it on DevNook, it lives in your Library, and you pick up right where you left off.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P2_3hWohigslC0UxNjOiCQ.png" /></figure><h3>Nova: The AI Assistant</h3><p>DevNook comes with a built-in AI assistant called <strong>Nova</strong>. She lives in the corner of the homepage and is ready to help you with anything, from explaining a concept, to guiding you toward the right course, to answering coding questions on the spot.</p><p>Nova is positioned not as a replacement for the learning content, but as a companion for when you get stuck or need direction. Ask her about React hooks, Python basics, or simply <em>“How do I get started?”</em> , she’s got you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5U7FywzlCLhaLeS4XGarlg.png" /></figure><h3>Blogs: Industry Insights for Developers</h3><p>The Blogs section is designed to host curated insights, tutorials, and industry news, <em>for developers, by developers</em>. It’s currently being built up, and articles will be going live soon covering topics like career advice, tool comparisons, coding tutorials, and more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Td1FE4yMAdrLyfR_9bhB0A.png" /></figure><h3>Contact &amp; Collaboration</h3><p>DevNook isn’t just a product, it’s a community. The Contact page makes it easy to reach out for general feedback, bug reports, content suggestions, or collaboration. Every message gets a real reply within 12–24 hours. No bots. No auto-replies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*li7PrX4YltnsrXIZZsrrFw.png" /></figure><h3>Who Is DevNook For?</h3><p>DevNook was really built for three kinds of people. The beginner who doesn’t know where to start and keeps bouncing between random YouTube videos. The intermediate developer who knows the basics but wants to go deeper without paying bootcamp prices. And the self-taught developer who just needs a bit more structure to tie everything together.</p><h3>What Makes DevNook Different?</h3><p>There are a lot of learning platforms out there. Here’s what makes DevNook stand out:</p><p><strong>It’s resource-first, not revenue-first.</strong> The content isn’t padded with fluff to justify a price tag. Every topic is written to be useful, concise, and actionable.</p><p><strong>It’s built for focus.</strong> No autoplay videos. No infinite scroll of unrelated content. You come in with a goal, you follow a path, you leave having learned something.</p><p><strong>It has a personal library.</strong> Bookmarking is built into the core experience, not an afterthought. Your saved content lives in one clean place.</p><p><strong>It has an AI assistant baked in.</strong> Not a chatbot plastered on as a marketing gimmick, Nova is genuinely useful for navigation, concept clarification, and learning support.</p><p><strong>It’s still growing.</strong> DevNook launched recently and is actively being built. The courses and topics you see now are just the beginning. The blog is launching, more courses are being added, and new features are on the way.</p><h3>What’s Coming Next</h3><p>DevNook is very much a living platform. Here’s what’s in the pipeline:</p><ul><li>A full blog with weekly articles on dev trends, tutorials, and career advice</li><li>More advanced courses across AI, backend development, and more</li><li>A premium tier for learners who want to go deeper with exclusive content</li><li>Sponsorships and partnerships with developer tool companies</li><li>A growing community of learners across the world.</li></ul><h3>Try It Yourself</h3><p>DevNook is live and free to explore right now. Creating an account takes less than a minute, and once you’re in, you can browse courses, read topics, save your favourites to your Library, and chat with Nova.</p><p>If you’re a developer, whether you’re just starting out or have been coding for years DevNook was built for you.</p><p><a href="https://www.getdevnook.com/"><strong>Visit DevNook at getdevnook.com</strong></a></p><p><em>DevNook is a modern knowledge platform for developers. Built with care, designed for focus, and growing every day.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffe3c330b048" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Development Methodologies]]></title>
            <link>https://medium.com/@wambuicecilia36/software-development-methodologies-1219fd3f24b9?source=rss-7dca8181154e------2</link>
            <guid isPermaLink="false">https://medium.com/p/1219fd3f24b9</guid>
            <category><![CDATA[software-methodology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[development-methodology]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[waterfall-methodologies]]></category>
            <dc:creator><![CDATA[WambuiCecilia]]></dc:creator>
            <pubDate>Thu, 06 Feb 2025 12:29:21 GMT</pubDate>
            <atom:updated>2025-02-07T05:42:40.926Z</atom:updated>
            <content:encoded><![CDATA[<p>Software development methodologies are the ways developers use to plan, execute, and deliver software projects. These approaches specify the structure, processes, roles, and strategies that govern software development from its inception to deployment and maintenance. Their goal is to increase the software development process’s efficiency, quality, and predictability.</p><h3>Purpose of Software Development Methodologies:</h3><ol><li>Create a clear roadmap for the entire development cycle.</li><li>Improve communication and collaboration between developers, stakeholders, and clients.</li><li>Allow project managers and teams to estimate deadlines, resources, and costs.</li><li>Include testing, validation, and feedback in the development process to achieve high-quality results.</li><li>Adapt to changes in requirements, technology, and consumer expectations.</li></ol><h3>Examples of Software Development Methodologies:</h3><ol><li>Waterfall Model</li><li>Agile Methodology</li><li>Lean Software Development</li><li>Rapid Application Development (RAD)</li><li>Scrum</li></ol><h3>1) Waterfall Model</h3><p>The Waterfall Model is a traditional, linear software development process in which each step of the project must be finished before the next can begin. It is commonly referred to as a “sequential” procedure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cYXzwsQOMQ-ppZe8" /></figure><h4>Advantages</h4><ul><li>Each phase is well-defined, making it easy to handle.</li><li>Simple for new team members to understand.</li><li>Clear documentation is provided at each level, which may be used for reference and auditing.</li></ul><h4>Disadvantages</h4><ul><li>It is difficult to return to prior phases once they are done. Any adjustments made later in the process are costly.</li><li>Testing is done after development, making it difficult to spot problems early.</li><li>Changes in requirements or technology may make the paradigm less effective for complicated or long-term projects.</li></ul><h4>Use Case</h4><ul><li>It works well for initiatives with well-defined, consistent requirements (for example, small-scale projects, government systems, or regulated sectors).</li></ul><h3>2) Agile Methodology</h3><p>Agile is a gradual and incremental approach that emphasizes collaboration, adaptability, and customer input. It focuses on releasing small, functional bits of software in regular intervals (sprints).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*i8spHg6AiGjV6iQm" /></figure><h4>Advantages</h4><ul><li>Easily handles changes in requirements.</li><li>Feedback loops provide continuous improvements throughout the project’s lifecycle.</li><li>Sets priorities for customer satisfaction by consistently delivering functional software.</li><li>Increments are supplied fast, bringing value to the consumer early and frequently.</li></ul><h4>Disadvantages</h4><ul><li>Flexibility can result in uncontrolled modifications and scope extension.</li><li>Clients must be available to provide comments and collaborate.</li><li>Timelines and expenditures might be difficult to predict in advance.</li></ul><h4>Use Case</h4><ul><li>Suitable for startups, new products, and working with novel or constantly evolving technologies.</li></ul><h3>3) Lean Software Development</h3><p>Toyota’s lean manufacturing concepts are the foundation of lean software development. It focuses on reducing waste while improving production. Using the guiding principles, developers can avoid non-productive activities while still producing high-quality work. The Toyota-inspired system also promotes continual learning and deferring judgments. It enables teams to have an open mind during development and weigh all options before making a choice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/0*r-BzJYh6mBcaj4pZ" /></figure><h4>Advantages</h4><ul><li>Focuses on minimizing non-value-adding operations, which leads to faster delivery.</li><li>Emphasizes ongoing improvement and frequent testing.</li><li>Sets priorities for features that provide the most value to customers.</li></ul><h4>Disadvantages</h4><ul><li>Teams may need to adapt to new processes, such as waste reduction and value-focused approaches.</li><li>It may be more difficult to run large-scale initiatives without good coordination.</li></ul><h4>Use Case</h4><ul><li>Ideal for startups and enterprises looking to reduce operational inefficiencies.</li></ul><h3>4) RAD (Rapid Application Development) Methodology</h3><p>RAD is an agile software development process that stresses rapid development and iteration, to provide functioning software in a shorter timeframe. RAD emphasizes prototypes, user feedback, and component-based construction, making it perfect for projects that require fast delivery and regular upgrades.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zOpn7vdVYjNLQX79" /></figure><h4>Advantages</h4><ul><li>RAD accelerates development by using prototypes and focusing on components.</li><li>Frequent iterations allow for adjustments depending on user feedback, making RAD more responsive to shifting needs.</li><li>Active user interaction guarantees that the finished product satisfies the user’s wants and expectations.</li><li>It decreases total development costs by emphasizing fast delivery and reusable components.</li></ul><h4>Disadvantages</h4><ul><li>RAD is usually more effective for small to medium-sized projects. It may not be suitable for huge systems with complex requirements.</li><li>Active and continual user interaction is required. If people are inaccessible or unsure about their needs, the process can be hampered.</li><li>Because of the rapid pace of development, there may be less emphasis on thorough testing, affecting overall quality.</li><li>RAD relies on the development team’s ability to swiftly build working prototypes and efficiently execute changes.</li></ul><h4>Use Cases</h4><ul><li>Ideal for projects that demand fast delivery and have variable or evolving requirements depending on user input.</li><li>Projects with a clearly defined user base that may provide ongoing input throughout the process.</li></ul><h3>5) Scrum Methodology</h3><p>Scrum is an Agile framework for managing and carrying out software development projects that emphasizes providing tiny, incremental changes in a controlled and iterative manner. It encourages cooperation, responsibility, and openness to deliver high-quality, functioning software in short “sprints.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/0*CkN44CkWmC8WNhMe" /></figure><h4>Advantages</h4><ul><li>Scrum enables teams to respond to changing requirements and priorities, making it incredibly flexible.</li><li>Regular meetings and updates provide transparency about the project’s progress and potential difficulties.</li><li>Scrum emphasizes close collaboration among the development team, stakeholders, and product owner.</li><li>Retrospectives and iterative cycles help teams continuously improve their methods and work output.</li><li>Scrum enables teams to release working software more frequently by focusing on delivering smaller increments throughout sprints.</li></ul><h4>Disadvantages</h4><ul><li>Due to Scrum’s flexibility, scope creep could occur if new needs are introduced to the product backlog without being properly prioritized.</li><li>Scrum requires all team members to be highly disciplined and adhere to Scrum traditions, which can be difficult for inexperienced teams.</li><li>Scrum is ideally suited for projects in which the final output may be divided into smaller portions. It may not be the ideal option for huge, monolithic projects with strict specifications.</li><li>Role descriptions can be difficult for teams to define, especially in smaller teams where individuals may be responsible for many tasks.</li></ul><h4>Use Cases</h4><ul><li>Ideal for projects with dynamic or evolving requirements (such as web development, app development, and systems that require regular upgrades).</li><li>Ideal for teams that can self-organize and manage their workload.</li><li>Best suited for projects that can benefit from regular releases of incremental software updates.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1219fd3f24b9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>