FluxChat
A distributed communication platform featuring 7 independent microservices, persistent WebSockets, squad stories, and sub-millisecond Redis session caching.
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.
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.
A distributed communication platform featuring 7 independent microservices, persistent WebSockets, squad stories, and sub-millisecond Redis session caching.
End-to-end booking infrastructure with role-based auth (RBAC), automated Razorpay webhooks, and QR vehicle verification.
Autonomous document ingestion, semantic chunking, and ChromaDB vector embeddings powered by Google Gemini.
Hardened cryptographic storage designed to protect confidential files, encrypted notes, and sensitive credentials with bcrypt and stateless JWT verification.
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.
Autonomous domain services communicating via asynchronous WebSockets, REST APIs, and event-driven Redis pub/sub queues.
Redis token-bucket rate limiting and in-memory session caching to safeguard database pools and guarantee sub-50ms roundtrips.
Stateless JWT authentication with cryptographically hashed secrets, client-side AES encryption, and role-based permissions.
Systematic pattern practice across core computer science paradigms to build intuition for optimal time and space complexity bounds.
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]
Rigorous computer science foundation paired with transparent engineering progress across active and upcoming systems.
Core Disciplines: Data Structures & Algorithms, Object-Oriented Programming, Database Management Systems, Operating Systems, Computer Networks.
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.
Feel free to initiate transmission through any of the channels below or submit the direct transmission form.