Backend

Task Manager — FastAPI Serverless Application

A serverless application built with FastAPI, deployed on AWS Lambda via Docker container images. Uses Mangum to deploy as serverless, Amazon DynamoDB for persistent data storage, and Redis (via AWS ElastiCache) for caching.

Overview

Tech Stack

Category	Technology
Framework	FastAPI
Runtime	Python 3.10
Deployment	AWS Lambda (Docker container)
ASGI Adapter	Mangum
Database	Amazon DynamoDB
Cache	Redis (AWS ElastiCache)
Authentication	JWT + Custom Crypto
Infrastructure	Terraform (IaC)

Project Structure

Root: backend/

app/api/v1/middleware/

JWT Authentication middleware — get_current_user_id

app/api/v1/routes/

FastAPI routers for Auth, Tasks, and Admin

app/config/

Environment variables loader, database client, and Redis client setup

app/services/

Core business logic — AuthService, TaskService, and AdminService

app/utils/

JWT and cryptographic helper functions

app/main.py

Application entrypoint and Mangum Lambda handler

terraform/

AWS infrastructure provisioning — VPC, ECR, API Gateway, DynamoDB, ElastiCache, IAM, Lambda

Dockerfile

Lambda container image specification

requirements.txt

Python dependencies definition

Database Schema (DynamoDB)

Users Table (USERS_TABLE)

Partition Keyuser_id (String — VAH... prefix and auto-increment sequence)

GSIemail-index (Partition Key: email)

Attributes

user_idusernameemailpasswordroleactivation_status

Tasks Table (TASKS_TABLE)

Partition Keyuser_id (String)

Sort Keytask_id (String — UUID)

Attributes

user_idtask_idtitledescriptionstatus (pending/ongoing/complete)created_at

Authentication Flow

Registration

POST /api/v1/auth/register — Generates unique 'VAH' user_id, encrypts password using custom crypto logic, stored with default 'user' role and 'active' status in DynamoDB Users Table.

Login

POST /api/v1/auth/login — Queries DynamoDB using email-index GSI, validates decrypted password, returns signed JWT via 'Bearer' token on success.

Protected Routes

get_current_user_id middleware intercepts requests, extracts Bearer token from header, validates it using JWT secret, and injects user_id.

Caching Strategy (Redis)

Cache Keytasks:{user_id}

TTL300 seconds (5 minutes)

Used ForGET /api/v1/tasks/fetch-task

InvalidationAggressively invalidated strictly upon task creation, update, or deletion operations

FallbackRedis connection issues immediately flag 'redis_disabled=True' globally to prevent continuous request latency; Redis is bypassed locally when ENVIRONMENT='development'.

API Endpoints

Authentication

POST/api/v1/auth/registerPUBLIC

Request Body

{
  "username": "string",
  "email": "string",
  "password": "string(length 6-15, special chars included)",
  "role": "string(optional)",
  "activation_status": "string(optional)"
}

Response: User details and activation status

POST/api/v1/auth/loginPUBLIC

Request Body

{
  "email": "string",
  "password": "string"
}

Response: access_token and token_type ('bearer')

GET/api/v1/auth/userAUTH

Get current authenticated user info and detailed task statistics

Response: task_data (counts per status) and user_data objects

Tasks

POST/api/v1/tasks/create-taskAUTH

Create a new assigned task

Request Body

{
  "title": "string",
  "description": "string"
}

Response: Generated task_id alongside input details

GET/api/v1/tasks/fetch-taskAUTH

Fetch all tasks for the logged in user (Cached heavily using Redis)

Response: List Array containing full task items

PUT/api/v1/tasks/update-task/{task_id}AUTH

Update specific task workflow status

Request Body

{
  "status": "string (pending/ongoing/complete)"
}

Response: Success notification reflecting action.

DELETE/api/v1/tasks/delete-task/{task_id}AUTH

Permanently delete task instance

Response: Status update signifying deletion

Admin

GET/api/v1/admin/usersAUTH

List all registered users (Strictly admin role required)

Response: Array of user objects containing system info

PUT/api/v1/admin/update-user/{user_id}AUTH

Update users administrative data (Admin only)

Request Body

{
  "username": "string(optional)",
  "email": "string(optional)",
  "password": "string(optional)",
  "activation_status": "string(optional)"
}

Response: Updated user validation status

Local Setup

python -m venv venv && source venv/bin/activate

Establish and link local virtual environment dependencies

pip install -r requirements.txt

Bulk assemble dependent libraries

cp .env.example .env

Copy settings locally into isolated '.env' reference. Initialize default parameters (Mandatory: ENVIRONMENT='development' to locally circumvent timeout latency defaults via AWS Redis routing attempts)

uvicorn app.main:app --reload

Serve and execute application via ASGI Uvicorn.

Environment Variables

Variable	Description	Example
`AWS_REGION`	AWS region location for resources (e.g. DynamoDB)	`us-east-1`
`USERS_TABLE`	Target DynamoDB users persistence table	`prod-users`
`TASKS_TABLE`	Target DynamoDB tasks persistence table	`prod-tasks`
`JWT_SECRET`	Secret salt encryption key for signing secure JWT tokens	`super_secret`
`PASS_SECRET_KEY`	Crypto secret used to encrypt/decrypt strings (passwords)	`crypto_secret_key`
`REDIS_HOST`	Endpoint URL for ElastiCache instance	`redis.cluster.local`
`REDIS_PORT`	Port connection index for ElastiCache instance	`6379`
`ENVIRONMENT`	System execution state context (Used frequently to flag DEV Redis interactions to avoid excessive timeout latency)	`development`

Deployment

Configure local credentials profile for AWS console targeting via CLI

Navigate workspace into 'terraform/' initializing workspace via 'terraform init' applying current 'main' module specifications representing VPC routing layers, App Gateway instances, IAM credential specifications, and Database instance formations.

Execute Docker compilation parameters to encapsulate logic matching specific Lambda AWS Python images and stream output instances directly towards respective dedicated ECR hosting registry endpoints.

Automate/Assign relevant new deployment hashes pointing newly active runtime handlers directly toward matching ECR targets containing the built source content payload.

Infrastructure (Terraform-provisioned)

VPC combined utilizing subnets scaling across networking tiers.

ECR repositories containing actively handled application logic versions built over python:3.10 lambda base structures.

API Gateway executing requests over standard HTTP routing.

AWS Lambda acting uniquely configured with Mangum integrations.

DynamoDB databases persisting elements incorporating diverse indexed global associations strategies.

ElastiCache defining managed integrated memory access.

IAM permissions managing deep functional interactions exclusively defining logic boundaries securely.

← Frontend Docs Home →