Building a Note Poster With React and Django!

by Tyronne on May 5, 2025

This blog post will guide you through the process of creating a simple yet functional note-posting application. Users will be able to write and display short notes, similar to digital sticky notes. We’ll leverage the power of React for a dynamic user interface and Django for a robust and scalable backend.

I. Setting Up the Development Environment

Before diving into the code, let’s ensure you have the necessary tools installed.

Python and pip: Django is a Python framework, so you’ll need Python installed on your system. Pip is Python’s package installer, which we’ll use to install Django. You can download Python from the official website (https://www.python.org/downloads/). Pip usually comes bundled with Python.

To verify your installation, open your terminal or command prompt and run:
Bash
```
python --version
pip --version
```
Node.js and npm (or yarn): React is a JavaScript library, and Node.js provides the JavaScript runtime environment. npm (Node Package Manager) is the default package manager for Node.js, although you can also use yarn. Download Node.js from (https://nodejs.org/). npm is installed along with Node.js.

Verify your installation:
```
node --version
npm --version
# or if you prefer yarn
yarn --version
```
Virtual Environment (Recommended for Django): It’s best practice to create a virtual environment for your Django project to isolate its dependencies.
```
python -m venv venv
# Activate the virtual environment
# On Windows:
venv\Scripts\activate
# On macOS and Linux:
source venv/bin/activate
```

II. Building the Django Backend

Now, let’s set up the backend using Django.

Install Django: With your virtual environment activated, install Django using pip:
```
pip install Django
```
Create a Django Project: Navigate to the directory where you want to create your project and run:
```
django-admin startproject noteposter_backend
cd noteposter_backend
```
Create a Django App: Inside your project directory (noteposter_backend), create a Django app to manage our notes:
```
python manage.py startapp notes
```

Define the Note Model: Open the notes/models.py file and define the Note model:

from django.db import models

class Note(models.Model):
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f"Note created at {self.created_at.strftime('%Y-%m-%d %H:%M:%S')}"

This model has a content field to store the note text and a created_at field to automatically record when the note was created

Make Migrations: Django uses migrations to manage database schema changes. Run the following commands to create and apply migrations:
```
python manage.py makemigrations notes
python manage.py migrate
```

Create API Endpoints (Views and URLs): Now, let’s create the API endpoints to handle note creation and retrieval. Open notes/views.py:

from rest_framework import generics
from .models import Note
from .serializers import NoteSerializer

class NoteListCreateView(generics.ListCreateAPIView):
    queryset = Note.objects.all().order_by('-created_at')
    serializer_class = NoteSerializer

We’re using Django REST Framework’s ListCreateAPIView to handle both fetching all notes (GET request) and creating new notes (POST request).

Create a Serializer: We need a serializer to convert our Note model instances into JSON and vice versa. Create a file named serializers.py inside the notes app directory:

from rest_framework import serializers
from .models import Note

class NoteSerializer(serializers.ModelSerializer):
    class Meta:
        model = Note
        fields = ['id', 'content', 'created_at']
        read_only_fields = ['id', 'created_at']

Define API URLs: Create a file named urls.py inside the notes app directory:

from django.urls import path
from .views import NoteListCreateView

urlpatterns = [
    path('api/notes/', NoteListCreateView.as_view()),
]

Then, include these URLs in your project’s main urls.py file (noteposter_backend/urls.py):

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

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('notes.urls')),
]

Install Django REST Framework: We used Django REST Framework, so make sure it’s installed:
```
pip install djangorestframework
```
Add 'rest_framework' to your INSTALLED_APPS in noteposter_backend/settings.py

INSTALLED_APPS = [

‘django.contrib.admin’,

‘django.contrib.auth’,

‘django.contrib.contenttypes’,

‘django.contrib.sessions’,

‘django.contrib.messages’,1

‘django.contrib.staticfiles’,

‘rest_framework’,2

‘notes’,

]

Enable CORS (Cross-Origin Resource Sharing): Since our React frontend will be running on a different port than our Django backend, we need to enable CORS to allow requests from the frontend’s origin. Install django-cors-headers:

pip install django-cors-headers

Add 'corsheaders' to INSTALLED_APPS in settings.py:

INSTALLED_APPS = [
    # ... other apps
    'corsheaders',
]

Add the CorsMiddleware to your MIDDLEWARE in settings.py. Make sure it’s placed before any middleware that might block CORS requests (like CommonMiddleware):

MIDDLEWARE = [
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

Finally, configure the allowed origins. For development, you might want to allow all origins:

CORS_ALLOW_ALL_ORIGINS = True

For production, you should specify the exact origins of your frontend application:

CORS_ALLOWED_ORIGINS = [
    "http://localhost:3000",  # Example React development server
    # "https://your-frontend-domain.com",
]

Run the Django Development Server:
```
python manage.py runserver
```
Your Django backend should now be running at http://127.0.0.1:8000/.

You can visit http://127.0.0.1:8000/api/notes/ in your browser (or use a tool like Postman) to see an empty JSON array (since we haven’t added any notes yet).

III. Building the React Frontend

Now, let’s create the frontend using React.

Create a React App: In a directory separate from your Django project (e.g., one level up), create a new React application using Create React App:
```
npx create-react-app noteposter_frontend
cd noteposter_frontend
```
Install Axios: We’ll use Axios for making HTTP requests to our Django backend:
```
npm install axios
# or
yarn add axios
```
Create Components: Let’s create the necessary React components:
- src/App.js: The main application component.
- src/components/NoteForm.js: A component for creating new notes.
- src/components/NoteList.js: A component to display the existing notes.

src/components/NoteForm.js:

import React, { useState } from 'react';
import axios from 'axios';

const NoteForm = ({ onNoteCreated }) => {
    const [content, setContent] = useState('');

    const handleSubmit = async (event) => {
        event.preventDefault();
        try {
            const response = await axios.post('http://localhost:8000/api/notes/', { content });
            setContent('');
            onNoteCreated(response.data); // Notify the parent component about the new note
        } catch (error) {
            console.error('Error creating note:', error);
        }
    };

    return (
        <form onSubmit={handleSubmit}>
            <textarea
                value={content}
                onChange={(e) => setContent(e.target.value)}
                placeholder="Enter your note here..."
                rows="4"
                cols="50"
            />
            <button type="submit">Add Note</button>
        </form>
    );
};

export default NoteForm;

This component provides a textarea for users to type their notes and a button to submit. When submitted, it sends a POST request to the Django API.

src/components/NoteList.js:

import React from 'react';

const NoteList = ({ notes }) => {
    return (
        <div>
            <h2>Notes</h2>
            {notes.length === 0 ? (
                <p>No notes yet.</p>
            ) : (
                <ul>
                    {notes.map(note => (
                        <li key={note.id}>
                            <p>{note.content}</p>
                            <small>Created at: {new Date(note.created_at).toLocaleString()}</small>
                        </li>
                    ))}
                </ul>
            )}
        </div>
    );
};

export default NoteList;

This component receives an array of notes as a prop and renders them in a list.

src/App.js:

import React, { useState, useEffect } from 'react';
import NoteForm from './components/NoteForm';
import NoteList from './components/NoteList';
import axios from 'axios';

function App() {
    const [notes, setNotes] = useState([]);

    useEffect(() => {
        fetchNotes();
    }, []);

    const fetchNotes = async () => {
        try {
            const response = await axios.get('http://localhost:8000/api/notes/');
            setNotes(response.data);
        } catch (error) {
            console.error('Error fetching notes:', error);
        }
    };

    const handleNoteCreated = (newNote) => {
        setNotes([newNote, ...notes]); // Add the new note to the beginning of the list
    };

    return (
        <div style={{ fontFamily: 'Arial, sans-serif', maxWidth: '800px', margin: '0 auto', padding: '20px' }}>
            <h1>Note Poster</h1>
            <NoteForm onNoteCreated={handleNoteCreated} />
            <NoteList notes={notes} />
        </div>
    );
}

export default App;

The App component manages the state for the notes. It fetches existing notes when it mounts and provides a callback (handleNoteCreated) to the NoteForm to update the list when a new note is created.

Run the React Development Server: Navigate to your noteposter_frontend directory and run:
```
npm start
# or
yarn start
```
Your React application should now be running at http://localhost:3000/.

IV. Connecting Frontend and Backend

With both the frontend and backend running, the React application should now be able to communicate with the Django API. When you add a note in the form, it will be sent to the Django backend, stored in the database, and then the updated list of notes will be fetched and displayed.

V. Further Enhancements

This is a basic implementation. Here are some ideas for further enhancements:

Styling: Add CSS or a UI library (like Material UI or Tailwind CSS) to make the application visually appealing.
Deleting Notes: Implement functionality to delete existing notes. This would involve adding a delete button to each note in the frontend and creating a corresponding API endpoint in the backend.
Editing Notes: Allow users to edit their notes. This would require a form to edit the note content and an API endpoint to handle updates.
User Authentication: Implement user accounts so that notes are associated with specific users.
Real-time Updates: Explore using WebSockets to push new notes to all connected clients in real-time without requiring a page reload.
Error Handling: Implement more robust error handling on both the frontend and backend.
Testing: Write unit and integration tests for both the frontend and backend.
Deployment: Learn how to deploy your React and Django applications to a production environment.

Conclusion

Building a note poster application with React and Django provides a solid foundation for understanding full-stack web development.

You’ve learned how to set up a Django RESTful API to handle data and how to build a dynamic user interface with React to interact with this API.

By exploring the suggested enhancements, you can further develop this application into a more feature-rich and sophisticated tool.

Remember to consult the official documentation for both React and Django REST Framework as you continue your development journey.

Happy coding!