Full-Stack Development Handbook

This document defines how we build, collaborate, and ship software.

1️⃣ Development Philosophy

Agile & Fast-to-Market

We do not build software in isolation for months. We build small, test fast, and improve continuously. The goal is not perfection — the goal is progress.

Delivering early allows:

  • Real user feedback
  • Reduced wasted effort
  • Faster learning cycles
  • Better product-market alignment

Minimum Viable Product (MVP)

An MVP is the simplest version of a feature that delivers value. It is NOT incomplete software — it is minimal but functional software.

When building an MVP, ask:
  • Is this solving the core problem?
  • Can this be simplified further?
  • Are we over-engineering?
  • Can we ship this within the sprint?

Overengineering slows teams down. As an intern, your job is to learn how to balance quality and speed.

2️⃣ Version Control & Collaboration

Why Git is Mandatory

Git is not just for saving code. It enables:

  • Tracking history
  • Safe collaboration
  • Code review workflows
  • Rollback to stable versions

Branch Architecture

We follow structured branch separation:

  • main → Production-ready code only
  • current → QA testing branch
  • dev → Active development
🚫 Direct push to main is strictly prohibited.

Branch Naming Convention

Branches must describe what they contain:

feat/321-add-user-authentication
bugfix/412-fix-login-validation
hotfix/501-fix-production-crash
wip/601-refactor-dashboard-layout

Commit Standards

Each commit must explain what was done AND why.

Format:
<Action performed>, resolves #<issue-number>

Example:
Add JWT authentication middleware, resolves #321

Pull Request Workflow

  1. Create branch from dev
  2. Make small, clean commits
  3. Push branch
  4. Create PR → target dev
  5. Request review
  6. Address review comments
  7. Merge only after approval

PR reviews are not criticism — they are collaborative improvement.

3️⃣ Frontend Engineering Roadmap

Phase 1: React Fundamentals

You will build a Todo Application from scratch. This teaches state management, component architecture, and CRUD logic.

  • Components & Props
  • useState & useEffect
  • Event handling
  • API calls
  • Folder structure best practices

Phase 2: Next.js + TypeScript

Next.js introduces production-level structure including:

  • App Router
  • Server vs Client components
  • API routes
  • Authentication flow
  • Environment variables

Phase 3: Figma to Production

You will learn how to convert design files into pixel-perfect responsive applications.

  • Reading design systems
  • Spacing & layout principles
  • Responsive breakpoints
  • Clean reusable components

4️⃣ Backend Engineering Roadmap

Phase 1: Python Core

Before building APIs, you must understand Python fundamentals, OOP, and project structure.

Phase 2: FastAPI

FastAPI is used for building high-performance APIs.

  • Routing
  • Pydantic validation
  • Dependency injection
  • JWT authentication
  • Database integration

Backend Architecture

We follow structured architecture:

  • Controllers → Handle requests
  • Services → Business logic
  • Repositories → Database interaction

5️⃣ Docker & DevOps

Why Docker Matters

Docker ensures that your application runs the same way on your laptop, staging server, and production server.

Core Concepts

  • Images
  • Containers
  • Dockerfile
  • docker-compose
  • Environment variables
docker build -t app .
docker run -p 8000:8000 app
docker-compose up --build

Every backend service must be dockerized before deployment.

📚 Learning Resources & References

🔹 Git & Version Control

🔹 React

🔹 Next.js & TypeScript

🔹 Figma & CSS

🔹 Python

🔹 FastAPI

🔹 Docker

6️⃣ Engineering Standards

  • Write clean, readable code
  • No console logs in production
  • Follow naming conventions
  • Self-review before PR
  • Ask when stuck — don’t silently struggle