InstaPro Architecture

1. System Architecture

InstaPro leverages a service-oriented, heavily cached architecture designed for high availability, low latency content delivery, and seamless parallel scaling across global regions.

Global Edge Network: Cloudflare acts as the global CDN and Web Application Firewall (WAF), caching static assets and terminating SSL close to the end-user.
Media Storage: Cloudinary manages real-time optimization, transformation, and distribution of images and videos upstream, reducing server footprint.
Load Balancing: AWS Application Load Balancers (L7) route traffic through path-based rules (e.g., /api to Node.js backend, / to Next.js servers).
Compute Layer: Containerized Node.js and Next.js applications deployed on Kubernetes (EKS/GKE), using Horizontal Pod Autoscalers (HPA) governed by CPU and request queues.
Data Layer:
- Primary DB: Managed PostgreSQL (Amazon Aurora) split into Primary (Write-heavy operations) and Read Replicas (Feed queries).
- Caching Layer: Redis Enterprise (ElastiCache) used for Session management, feed caching, rate-limiting, and Pub/Sub bridging.
Real-time Layer: Purpose-built stateless Socket.io cluster instances glued by Redis Adapter to push notifications and direct messages instantly.

2. Frontend Architecture

The client is built using Next.js (App Router) and React to aggressively leverage SSR for SEO-sensitive pages (Profiles, Post Permalinks) and CSR for highly dynamic, personalized paths (Main Feed, Messaging).

Core Paradigm

State Management: Zustand for global lightweight state (current user, UI overlays) and React Query (TanStack Query) for server-state caching, optimistic UI updates, and infinite scrolling feeds.
Styling Methodology: Tailwind CSS for strict utility-first styling alongside Headless UI components (Radix UI) for robust accessibility.
Media Handling: Next.js <Image> wrapped over remote patterns pointing to Cloudinary CDN for instant WebP/AVIF format switching and device-aware sizing.
Performance Hacks:
- Pre-fetching feed data during splash screen or layout load.
- Virtualization (using react-window) for rendering extremely long feeds securely without dominating the DOM tree.

3. Backend Architecture

A robust Node.js + Express monolithic service (layered modularly for easy future microservice extraction if constraints arise) written purely in strict TypeScript.

Application Layers (Domain-Driven)

Controllers: Extracting request payload and returning mapped responses. No business logic exists here.
Services: Core business logic execution (e.g., Feed Generation algorithm, Authentication handshakes).
Data Access Layer (Repositories): Abstractions over TypeORM/Prisma querying the PostgreSQL instances.

Feed Generation Strategy (10M+ Users)

For standard users, InstaPro utilizes a Push (Fan-out on Write) model combined with Redis. When a user posts, the system pushing the Post ID to the Redis List of all their active followers. For celebrities (Millions of followers), a Pull (Hybrid) model retrieves their posts upon feed generation to prevent massive write bottlenecks.

4. Database Architecture

PostgreSQL 16+ operates as the source of truth, enforcing stringent relational integrity.

// users

uuid id (PK)
varchar username (UNIQUE, INDEX)
varchar email (UNIQUE)
varchar avatar_url
text bio
timestamp created_at

// posts

uuid id (PK)
uuid user_id (FK, INDEX)
varchar media_url
text caption
int likes_count
timestamp created_at (INDEX)

// follows

uuid follower_id (FK, PK_1)
uuid following_id (FK, PK_2)
timestamp created_at
-- Indexed on follower_id for feeds

// likes

uuid post_id (FK, PK_1)
uuid user_id (FK, PK_2)
timestamp created_at

5. API Architecture

Exposed predominantly as a RESTful API returning structured JSON, unified under the /api/v1 prefix.

Pagination: Strictly configured to use Cursor-based pagination (combining `created_at` timestamp and UUID) rather than `offset/limit` to guarantee performance down to millions of deeply scrolled rows.
Payload Validation: Enforced globally at layer-1 using Zod schemas before reaching controllers, preventing malformed payload injection.
WebSockets: Exposed under ws://api.instapro.com/socket.io authenticating upgrading sockets via JWT passed in headers/tickets.

6. Security Architecture

Authentication: JWT-based decoupled flows.
- Access Token: Short-lived (15 minutes), passed in Memory / Authorization Headers.
- Refresh Token: Long-lived (7 days), strictly secured within a HttpOnly, Secure, SameSite=Strict cookie, drastically mitigating XSS risks.
Password Hashing: bcrypt with salt rounds scaling contextually to compute power.
Rate Limiting: Enacted at the Nginx ingress and Express middleware level via Redis blocks to throttle aggressive API scrapping and DDOS vectors.
CORS Policy: Strictly whitelisting trusted Web and Mobile App domains exclusively.

7. DevOps Architecture

InstaPro adheres to GitOps methodologies, guaranteeing that main-branch code equates strictly to infrastructure truth.

Containers: Multi-stage Dockerfiles strip out development dependencies for minimal, highly secure alpine/distroless production payloads.
CI/CD Pipelines (GitHub Actions):
- PR Stage: Lint (ESLint), Typecheck (tsc), Unit Tests (Jest), Integration Tests.
- Merge Stage: Build Image, Tag SHA, Push to ECR/GCR.
- Deploy Stage: Trigger ArgoCD to update Kubernetes cluster manifests smoothly (Rolling Updates to assure zero-downtime).
Telemetry: Prometheus for metric scrapping, Grafana for visual dashboards, and Datadog for APM tracing.

8. Folder Structure

insta-pro-monorepo/├── apps/│   ├── web/                 # Next.js Application│   │   ├── app/ │   │   ├── components/ │   │   │   ├── ui/            # Shared Atoms (Buttons, Inputs)│   │   │   └── feed/          # Feature-specific components│   │   ├── hooks/ │   │   ├── lib/ │   │   └── tailwind.config.ts │   │ │   └── api/                 # Node.js + Express Backend│       ├── src/ │       │   ├── controllers/   # Route to Service routers│       │   ├── services/      # Brains & Business Logic│       │   ├── models/        # DB schemas (Prisma/TypeORM)│       │   ├── routes/        # Express endpoint definitions│       │   ├── middlewares/   # Auth Guard, Rate Limiter│       │   └── sockets/       # Socket.io event receivers│       ├── Dockerfile │       └── package.json │ ├── packages/             # Shared Monorepo Code│   ├── database/          # Shared Prisma setup & Migrations│   └── types/             # Shared TypeScript Interfaces│ ├── docker-compose.yml     # Local Dev (PG, Redis, Node, Next)└── .github/workflows/     # CI/CD Pipelines