KAHIBARO
Discord Login Register ☰
☰

33.1. What You Should Know Now

Table of Contents

Big Picture: Where You Are Now

By the time you reach this chapter, you should have walked through the full backend stack at least once. You are not expected to master everything yet. What matters is:

This chapter is a checklist and reflection guide. Use it to see what you already know, what is still fuzzy, and what to review next.

Rule: Treat this chapter as a skills checklist, not as a new theory lesson. Mark each area as:

  • ✅ Confident
  • 🟡 Understand a bit
  • 🔴 Need to study and practice

Core Concepts of Backend Development

You should now be able to describe, in your own words:

Try to answer these questions without looking at notes:

  1. What is the difference between a client and a server?
  2. What is the request-response cycle?
  3. What is an API and why do frontends call it?

If you struggle to give a clear 2 or 3 sentence answer, mark this area as 🟡 or 🔴 and revisit those earlier chapters.

A tiny self-check exercise:

ConceptCan you do this?Status
Explain backend in 2–3 linesDescribe to a non-technical friend what a backend is
Draw architectureDraw a simple diagram: browser → API server → database
Explain RESTExplain why REST APIs use URLs, HTTP methods, and status codes

Fill in the "Status" for yourself.

Web and HTTP Knowledge

Backend development is deeply tied to HTTP and to how the web works.

At this point you should:

Try to mentally walk through this scenario:

A user opens https://example.com/api/tasks?completed=false in the browser.

You should be able to say:

A quick recall table:

TopicYou should be able to…Status
URL structurePoint out protocol, domain, path, query parameters
HTTP methodsSay when to use GET vs POST vs PUT vs DELETE
Status codesPick the right status for success, not found, validation errors
Headers, cookies, authExplain the basic idea of headers and cookies for auth and sessions

If you cannot quickly think of an example of each, review the web and HTTP chapters.

Programming and Python Fundamentals

You have used Python as your main backend language. You should now be comfortable with:

In practical backend terms, that means:

A simple self-check snippet:

Ask yourself if you can implement something like this from scratch:

python 
# validation.py
def validate_task_payload(payload: dict) -> dict:
    if "title" not in payload or not payload["title"]:
        raise ValueError("Title is required")
    payload.setdefault("completed", False)
    return payload

And then use it inside a FastAPI route. If that feels too hard, you need more Python and error handling practice.

Mini checklist:

Python topicPractical ability you should haveStatus
FunctionsWrite small reusable functions with arguments and return values
Data structuresUse lists and dicts to represent tasks, users, etc.
ExceptionsUse try / except to handle predictable errors
ModulesSplit code into multiple .py files and import between them
OOP basicsCreate simple classes and understand attributes and methods

Building Web Backends and REST APIs

You have written at least one simple REST API, probably with FastAPI. Even if everything is not fluent yet, you should at least:

For example, you should be able to read this and understand every part:

python 
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class TaskCreate(BaseModel):
    title: str
    completed: bool = False
class Task(TaskCreate):
    id: int
tasks_db: list[Task] = []
@app.post("/tasks", response_model=Task, status_code=201)
def create_task(task: TaskCreate):
    new_id = len(tasks_db) + 1
    new_task = Task(id=new_id, **task.dict())
    tasks_db.append(new_task)
    return new_task

You should be able to answer:

Self-check:

API conceptWhat you should be able to doStatus
Routes / endpointsAdd a new route to an existing FastAPI app
Path & query paramsRead and use URL parameters in handlers
Request bodyRead JSON into a Pydantic model and validate required fields
Response modelsReturn consistent shapes for responses
Error responsesReturn 400, 404, etc with a JSON error message

If you have never added an endpoint yourself or changed an existing one, plan to practice this soon.

Databases and SQL Basics

You were introduced to relational databases, PostgreSQL, and SQL.

At this point, you should:

For example, you should be able to understand queries like:

sql 
CREATE TABLE tasks (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    completed BOOLEAN NOT NULL DEFAULT FALSE
);
INSERT INTO tasks (title) VALUES ('Learn backend');
SELECT * FROM tasks WHERE completed = FALSE;

Do a quick mental test:

Self-check:

Database topicYou should be able to…Status
Tables & rowsDescribe a table as a spreadsheet with rows and typed columns
Primary keysExplain why every row needs a unique identifier
Simple queriesWrite SELECT, INSERT, UPDATE, DELETE with WHERE
Joins (basic idea)Explain why joins connect data from related tables

At this stage, you do not need advanced SQL or performance tuning, only the basics.

ORM and Integrating Databases with Code

You have seen how to connect Python code to a database using an ORM such as SQLAlchemy.

You should now:

For instance, consider this simplified model:

python 
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, Boolean
class Base(DeclarativeBase):
    pass
class Task(Base):
    __tablename__ = "tasks"
    id: Mapped[int] = mapped_column(primary_key=True, index=True)
    title: Mapped[str] = mapped_column(String, nullable=False)
    completed: Mapped[bool] = mapped_column(Boolean, default=False)

You should understand:

Checklist:

ORM conceptAbilityStatus
ModelsDefine a basic model that maps to a table
CRUD operationsUse an ORM session to add, query, update, and delete objects
SessionsUnderstand that sessions represent a database connection context
Simple relationshipsHave at least seen one-to-many relationships in ORM

If you have not yet connected your FastAPI app to a real database, this is a great next practice step.

Authentication, Security, and Sessions

You were introduced to authentication concepts like passwords, tokens, and sessions.

You should now:

You do not need to design a production grade security system yet, but:

Self-check:

Security topicMinimal understanding you should haveStatus
Auth vs authzCan explain difference in 1 sentence each
Password hashingKnow why hashing is needed and what happens if you skip it
Tokens / sessionsKnow the idea of storing login state on client or server
Basic security risksRecognize names: SQL injection, XSS, CSRF, brute force

If these words are completely new or confusing, plan to revisit the security chapters.

Tools: Git, Docker, and Deployment Basics

You were exposed to tooling that real backend developers use daily.

By now you should:

You do not need to be a DevOps expert, but you should not be scared of:

Self-check:

ToolingPractical skillStatus
Git basicsgit init, git add, git commit, git push
BranchesCreate and switch branches, merge basic changes
GitHub / GitLabHost a repository and clone/pull from it
Docker (basic)Understand image vs container and read a simple Dockerfile

Project Skills: From Requirements to Working API

You have completed or at least seen multiple projects, such as:

From these, what matters most is that you:

Think about one project you completed in this course and check:

Project aspectCan you do this independently now?Status
Understand requirementsTurn a text spec into a list of resources and endpoints
Design basic schemaSketch tables and relationships for the main entities
Implement APICreate endpoints that match the design and connect to DB
Add authProtect at least some endpoints with login / tokens
Test manuallyUse an API client to check responses and edge cases

If the answer is no in many rows, pick one project and rebuild it slowly, step by step.

How to Use This Checklist

To get real value, do not just read this chapter. Actually:

  1. Print or copy the tables.
  2. For each row, mark your current status: ✅, 🟡, or 🔴.
  3. Pick at most 2 red areas to focus on in the next couple of weeks.
  4. Plan small practice tasks for those areas.

Example practice tasks:

Important: Do not try to fix everything at once.
Choose a small number of weak areas, practice them with tiny projects, and then revisit this checklist.

The Minimum You Should Know Now

Summarizing, by this point you should at least:

If you can honestly say "yes" to most of these items, you are ready to move on to:

If not, this is not a failure. It is simply a map of where to go back and practice. Keep this chapter as your reference, and return to it as you grow as a backend developer.

Views: 6

Comments

Please login to add a comment.

Don't have an account? Register now!

© 2025 Kahibaro
Visitors: 2994 / 24h
Impressum / Imprint
Datenschutz / Data Policy