Remindly
Academic task management and deadline tracking system built with a decoupled architecture: a separate FastAPI backend using SQLAlchemy and Pydantic validation, paired with a React and Next.js frontend.
Context & Problem Statement
Students frequently struggle with disjointed deadlines across academic courses, leading to missed assignments and poor prioritization.
Existing productivity applications are often overloaded with bloated collaboration features, slow load times, or opaque scheduling mechanisms.
The engineering goal was to build a clean, responsive task tracking system with clear separation between a high-performance Python API and a typed modern frontend.
- [01]Design a decoupled REST API with strict request and response contracts using FastAPI and Pydantic.
- [02]Implement secure stateless authentication via JWT tokens with password hashing.
- [03]Deliver an intuitive frontend with instant state updates and clear priority queues.
Technical Approach & Key Decisions
Structured the application into two independent codebases: a separate FastAPI backend handling business logic and data persistence, and a React/Next.js frontend focused on responsive user interactions.
Decoupled Architecture
Separating frontend and backend enables independent versioning, deployment, and distinct technology optimization without framework coupling.
FastAPI & Pydantic Contracts
Pydantic schemas enforce type safety at the API boundary, guaranteeing structured JSON parsing, automatic 422 error handling, and OpenAPI documentation.
Stateless JWT Authentication
Used JSON Web Tokens signed with HS256 for lightweight, stateless session management across requests with bearer authorization.
SQLAlchemy ORM Mapping
Defined relational models with explicit foreign keys between User and Task entities, ensuring clean queries and relationship cascading.
Architecture & Layer Breakdown
The system features a separate FastAPI backend serving JSON endpoints to a React/Next.js frontend. Requests carry bearer JWT tokens validated via dependency injection.
Frontend Layer (React / Next.js)
TypeScript interface rendering dynamic task queues, priority badges, and deadline indicators with Tailwind CSS.
- Component-level state handling
- Optimistic task status toggling
- JWT bearer token request interceptors
Backend Layer (FastAPI)
ASGI application organized into modular APIRouters with dependency injection for database sessions and current user context.
- Modular APIRouters (Auth, Tasks)
- OAuth2PasswordBearer authentication
- Pydantic schema serialization
Persistence Layer (SQLAlchemy)
Relational database access with declarative ORM models and migrations.
- Declarative model definitions
- User and Task foreign key constraints
- Scoped database sessions
Key System Capabilities
Stateless JWT Auth
SecuritySecure user registration and login issuing signed JSON Web Tokens, validated on protected routes via FastAPI dependencies.
Structured Task Lifecycle
CoreComprehensive task state management supporting priority levels (low, medium, high), due date scheduling, and status transitions.
Strict Pydantic Schema Validation
Data QualityAll incoming payloads and outgoing responses are strictly validated and typed, eliminating malformed data payloads.
Automated API Documentation
Developer ExperienceNative OpenAPI and Swagger UI generation providing interactive endpoint exploration and debugging.
Results & Impact
Established a clean decoupled application demonstrating robust communication between a Python ASGI service and a TypeScript web client.
Enforced type safety end-to-end: TypeScript interfaces on the client aligning with Pydantic schemas on the server.
Delivered a lightweight, responsive task management tool with zero extraneous bloat.
Challenges & Considerations
- •Managing token expiration gracefully on the client without interrupting user actions during active task edits.
- •Configuring cross-origin resource sharing (CORS) and handling preflight OPTIONS requests securely in development and deployment environments.
Key Learnings
- •Architecting Remindly reinforced the value of contract-first API design. When backend schemas and frontend types are synchronized, feature additions become predictable and defect rates drop significantly.