[ SYS_READY // OPEN TO OPPORTUNITIES ]

Hi, I'm Jitu.

I build full-stack, AI-powered & scalable systems.

A Computer Science and Engineering student who enjoys turning complex problems into practical software. I work across full-stack development, backend systems, AI/GenAI, and cloud technologies to build real-world applications.

Jyoti Swarup Parhi developing systems
“Better Software, A Brighter Tomorrow”
LAT: 20.2961° N • LON: 85.8245° E
Building
Learning
Shipping
— Jitu
jitu@arch-linux:~ [LIVE SHELL]
$ whoami
Jyoti Swarup Parhi
$ role
Full-Stack Developer
$ focus
AI • Backend • Systems
$ status
Open to opportunities
$
React
Next.js
Node.js
Python
AWS
Docker
[DEGREE]
B.Tech
Computer Science & Eng.
[TIMELINE]
2027
Target Graduation
Active
Continuous Code on GitHub
[DSA_LOG]
Daily
Consistent Problem Solving
ABOUT_ME // ARCHITECTURE

Building Real-World Solutions with Code

I'm Jyoti Swarup Parhi, a Computer Science and Engineering student at GITA Autonomous College, Bhubaneswar. I enjoy building full-stack applications, backend systems, and AI-powered solutions.

I'm deeply interested in microservices, real-time systems, cloud technologies, and solving challenging problems through code.

Available for Software Engineering Internships & Roles
Connect Directly →

Engineering Focus

[SYSTEM_DOMAINS]
Full-Stack Development
Backend Engineering
Microservices
Real-Time Systems
AI / RAG
Cloud & DevOps
System Design
Problem Solving
“I believe in building products that solve real problems and create real impact.”
— Jyoti Swarup Parhi
PHILOSOPHY // ENGINEERING
TECH_STACK // CAPABILITIES

Tools & Technologies I Work With

Explore Implementations →
{ } Languages
Python Logo
Python
Java Logo
Java
C Logo
C
JavaScript Logo
JavaScript
< / > Frontend
HTML5 Logo
HTML5
CSS3 Logo
CSS3
React Logo
React
Next.js Logo
Next.js
Backend
Node.js Logo
Node.js
Express Logo
Express
FastAPI Logo
FastAPI
Flask Logo
Flask
Databases
PostgreSQL Logo
PostgreSQL
MongoDB Logo
MongoDB
MySQL Logo
MySQL
Firebase Logo
Firebase
AI / ML
TensorFlow Logo
TensorFlow
PyTorch Logo
PyTorch
scikit-learn Logo
scikit-learn
OpenCV Logo
OpenCV
DevOps & Cloud Infrastructure [CLOUD_ENGINEERING]
Docker Logo
Docker
Kubernetes Logo
Kubernetes
AWS Logo
AWS
GitHub Logo
GitHub
Linux Logo
Linux
Other Tools & Automation
Postman Logo
Postman
Google Colab Logo
Colab
Git Logo
Git
CASE_STUDIES // PRODUCTION

Turning Ideas into Real-World Applications

View All Projects on GitHub →
FluxChat interface mockup Featured • WebSockets Live
PROJ_01 // 7_MICROSERVICES

FluxChat

Real-Time Chat & Collaboration Platform

A distributed communication platform featuring 7 independent microservices, persistent WebSockets, squad stories, and sub-millisecond Redis session caching.

Next.js 16 FastAPI MongoDB Redis Pub/Sub Docker
Live App ↗ Interactive Case Study → GitHub
RentHub vehicle platform mockup Upcoming
PROJ_02 // UPCOMING

RentHub

Multi-Tenant Vehicle Rental Platform

End-to-end booking infrastructure with role-based auth (RBAC), automated Razorpay webhooks, and QR vehicle verification.

React Node.js PostgreSQL Razorpay
Upcoming Project View Details →
Gemini RAG Studio dashboard mockup AI System
PROJ_03 // GENAI_RAG

Gemini RAG Studio

Retrieval-Augmented Generation Backend

Autonomous document ingestion, semantic chunking, and ChromaDB vector embeddings powered by Google Gemini.

Python FastAPI ChromaDB Google Gemini
Live Demo ↗ View Architecture → GitHub
Personal Vault security UI Security Vault
PROJ_04 // CRYPTO_VAULT

Digital Vault

Zero-Knowledge Digital Asset & Document Management

Hardened cryptographic storage designed to protect confidential files, encrypted notes, and sensitive credentials with bcrypt and stateless JWT verification.

React Node.js Supabase Bcrypt AES-256
Live App ↗ View Case Study → GitHub
SYSTEM ARCHITECTURE // TOPOLOGY

From Idea to Scalable Systems

I focus not only on building responsive interfaces, but also on how services communicate, how data flows, how caching is invalidated, and how systems scale reliably.

01 CONCEPT
—›
02 ARCHITECTURE
—›
03 IMPLEMENTATION
—›
04 TESTING & CI/CD
—›
05 CLOUD DEPLOY
01

Decoupled Microservices

Autonomous domain services communicating via asynchronous WebSockets, REST APIs, and event-driven Redis pub/sub queues.

02

Sub-Millisecond Caching

Redis token-bucket rate limiting and in-memory session caching to safeguard database pools and guarantee sub-50ms roundtrips.

03

Zero-Trust Security & RBAC

Stateless JWT authentication with cryptographically hashed secrets, client-side AES encryption, and role-based permissions.

SYS_TOPOLOGY // V.24 HIGH-AVAILABILITY CLUSTER
User Client Browser
Frontend Next.js / React
API Gateway Reverse Proxy
Services Node.js / FastAPI
Database Postgres / Mongo
Auth JWT / RBAC
Cache Redis Tokens
External APIs AWS / 3rd Party
System Layer: User • Client Browsers & Mobile
Initiates secure HTTPS and WebSocket connections. Handled with optimized single-page hydration, client caching, and responsive typography across all form factors.
ALGORITHMIC RIGOR // DATA STRUCTURES

Problem Solving & Complexity Targets

Systematic pattern practice across core computer science paradigms to build intuition for optimal time and space complexity bounds.

CORE ALGORITHMIC PATTERNS 19 PATTERNS PRACTICED
01 Array 02 Hash Table 03 Two Pointers 04 Binary Search 05 Greedy Approach 06 Dynamic Programming 07 Recursion 08 Memoization 09 Linked List 10 Stack 11 Monotonic Stack 12 Tree 13 Binary Search Tree 14 Binary Tree 15 Matrix Operations 16 Prefix Sum 17 Sorting 18 String 19 Bit Manipulation
19 Categories Practiced
O(1) Target Space Bound
Daily Practice Cadence
LRUCache.py — Hash Map + Doubly Linked List O(1) Time • O(Capacity) Space
class Node:
    def __init__(self, key: int, val: int):
        self.key, self.val = key, val
        self.prev = self.next = None

class LRUCache:
    """O(1) Get and Put via Hash Map + Doubly Linked List"""
    def __init__(self, capacity: int):
        self.cap = capacity
        self.cache = {} # key -> Node
        self.head, self.tail = Node(0, 0), Node(0, 0)
        self.head.next, self.tail.prev = self.tail, self.head

    def _remove(self, node: Node):
        prev, nxt = node.prev, node.next
        prev.next, nxt.prev = nxt, prev

    def _insert(self, node: Node):
        nxt = self.head.next
        self.head.next = node
        node.prev, node.next = self.head, nxt
        nxt.prev = node

    def get(self, key: int) -> int:
        if key in self.cache:
            node = self.cache[key]
            self._remove(node)
            self._insert(node)
            return node.val
        return -1

    def put(self, key: int, val: int) -> None:
        if key in self.cache:
            self._remove(self.cache[key])
        node = Node(key, val)
        self._insert(node)
        self.cache[key] = node
        if len(self.cache) > self.cap:
            lru = self.tail.prev
            self._remove(lru)
            del self.cache[lru.key]
ACADEMICS & ROADMAP // LIFECYCLE

Education & System Roadmap

Rigorous computer science foundation paired with transparent engineering progress across active and upcoming systems.

ACADEMIC FOUNDATION
2023 — 2027

B.Tech in Computer Science & Engineering

GITA Autonomous College, Bhubaneswar
8.6 CGPA • Full-Time Undergraduate

Core Disciplines: Data Structures & Algorithms, Object-Oriented Programming, Database Management Systems, Operating Systems, Computer Networks.

2021 — 2023

Higher Secondary Certificate (Class XII • Science)

NRI International School, Bhadrak • 69.9%
2020 — 2021

Secondary School Certificate (Class X)

Royal Public School Bidya Bihar, Balasore • 61.2%
ENGINEERING ROADMAP
PHASE 01 // COMPLETED & SHIPPED
FluxChat Distributed WebSockets Distributed Auth & Session Vault Gemini RAG Vector Ingestion Personal Vault Crypto Storage
PHASE 02 // ACTIVELY IN DEVELOPMENT
RentHub Multi-Tenant Rental Platform Multi-Agent GenAI Autonomous Pipelines WebRTC Mesh Audio/Video Rooms High-Throughput Redis Rate Limiting
PHASE 03 // RESEARCH & EXPLORATION
Kubernetes Multi-Cluster Orchestration Distributed Consensus (Raft / Paxos) Low-Latency Systems in Rust & Go
COMMS // DIRECT TRANSMISSION

Let's Build Systems Together

Looking for a full-stack engineer who builds scalable systems, microservices, and AI-powered platforms? I am open to software engineering internships, full-time positions, and technical collaborations.

Transmission Dispatch