Code Infinity Research and Development Organization - CIRDO

Building the "brain" of EdFlix 🧠

I’ve been working hard on EdFlix, and one of the coolest parts is the recommendation system. I wanted to make sure that when someone logs in, they see exactly what they need to learn next, without having to dig for it.

Here’s the simple version of how I set it up:

The Signal: Every time someone clicks or watches something, it sends a little data packet (JSON).

The Traffic Controller: I use Kafka to handle all that data. It’s like a massive sorting center that makes sure the app stays fast even when tons of people are using it at once.

The Logic: That data goes into an Event Hub where it gets cleaned up and saved into a database. This is how the system "remembers" what you like.

The Guess: I built a Model that looks at your history and your current "vibe" (like what device you're on) to predict what you'll enjoy.

The Result: A small Micro-service grabs those predictions and puts them right on your screen in real-time.

It’s been a fun challenge to move away from just "showing a list of videos" to actually making the platform feel smart.

Want to build stuff like this? We're growing the team at nfrac:

🔬 If you love Research: Join the NFRAC's Dept of AI. We're building models from the ground up (low-level).

🛠️ If you love Applied AI/ML: Join the TattvaAI team at nfrac-vtc.

Excited to Launch Project 138 'PicSafe' - A Private Space for Your Photos

In a time where digital privacy is increasingly important, I set out to build something simple, secure, and fully under the user’s control.

Introducing PicSafe, a cross-platform mobile application designed to protect personal images with complete privacy.

What makes PicSafe different:

• 100% offline - your data never leaves your device

• Encrypted image storage using native device capabilities

• Fast and scalable - supports 500+ images with smooth performance

• Built with Capacitor for seamless iOS and Android experience

No cloud. No tracking. Just your photos, safe and private.

This project reflects my focus on security, mobile development, and building practical solutions that solve real problems.

I would appreciate your feedback and support as I continue to improve PicSafe.

Garuda Libraries - Open Source Collaboration !!!!
I’m building Garuda Libraries solo for the Garuda Programming Language and inviting contributors to join.
Looking for: system programmers, backend devs, compiler/tooling enthusiasts, docs writers.
Contribute to: core libraries, data structures, networking, utilities, and dev tools.
Be an early contributor and help shape this ecosystem from scratch!
DM or comment to collaborate.
(https://lnkd.in/gV2tRCtx)

Pushing a step further on YAARI --update--.

Today, I’m rolling out 'Goto HotSpots' on Yaari, a location-driven layer that lets users discover what’s actually happening around them, in real time.

Users can now find the best HotSpots within a 7 km radius and seamlessly navigate to any location using maps, directly inside Yaari.

The goal is simple: reduce the gap between online interaction and offline experience.

Instead of just seeing content, you can now navigate to places worth your time, cafes, hangouts, and local spots directly from within Yaari.

This is an early iteration. The focus right now is on building a clean, scalable foundation for location-based discovery inside a social graph.

More improvements coming as we learn from usage.

Before learning Java Spring Boot, you should first look at these basic examples of server-client communication.
Think of this like the bare minimum truth of backend systems (Best case, single thread).
The client reads a file in small chunks and sends them one by one.
The server receives each request, validates the token, and processes the data.
That’s it.
But inside this SIMPLE flow, you’re learning:
How HTTP requests actually work (headers, body, status codes)
Why chunking is used (handling large data safely)
Why every request needs authentication (security is not optional)
How servers handle multiple requests (threads)
Spring Boot will later hide all of this behind annotations and configs.
But if you understand this first, you won’t just use Spring Boot, you’ll know what it’s doing behind the scenes.
And that’s what makes you a real backend engineer.

Want to dive deeper BEHIND THE SCENES ? At ITTacademy, we take you from zero to pro, master backend systems from scratch.
Book your demo class today, for free! 🚀

Yaari --update--

Just added a new 'Calling' feature on Yaari, because no matter how far your friends are, one call can bring them right next to you. Distance fades, Connections stay. You can make calls from Phones, Laptops or even Computers, so let me know if you are a Yaari and have used this new feature !!

Also a minor update under the hood, you can now share your pictures to other social media platforms right from 'Yaari' with ONE click.

Try out these new features and let me know in the comments below !!

Dm to join the Yaari team at NFRAC-VTC, lets buckle up and create some impact.

🚀 Introducing “Click & Upload” on Yaari, a Faster, Smarter, and Seamlessly Secure way to share pics. (https://yaari-jud.web.app)

Today, I am excited to roll out "Click & Upload", a new feature designed to make sharing moments on Yaari feel instant. One tap, one permission, one smooth upload, that’s the experience we set out to build.

But behind that simple interaction is a surprisingly sophisticated pipeline. To make “Click & Upload” truly reliable across both Android and iOS, I've re‑engineered how our app handles permissions, native calls, and data flow end‑to‑end.

Here’s a peek under the hood:

🔹 User taps “Camera” → The app triggers a request through Capacitor
🔹 Capacitor bridges to Native Plugins, which act as the gatekeepers for device‑level capabilities
🔹 Native Plugins communicate directly with Android and iOS kernels to request the necessary permissions
🔹 The OS validates and grants access, ensuring the user stays in full control
🔹 Permissions are passed back up the chain, enabling the app to proceed
🔹 The media payload is securely sent to our servers, where it’s stored and processed
🔹 Everything happens in milliseconds, giving users a smooth, instant experience

This upgrade isn’t just about convenience, it’s about building a permission flow that’s transparent, secure, and engineered for scale. By tightening the bridge between Capacitor, native layers, and OS‑level validation.

Yaari users get a simple “Click & Upload.”
Under the hood, it’s a carefully orchestrated dance of SDK calls, kernel‑level checks, and backend reliability.

🚀 Launching My 137th Application- Clip Away (https://clip-away.web.app)

I’m excited to share the launch of my 137th application: Clip Away, an intelligent background removal platform powered by U²-Net deep learning architecture. This project combines AI-based image segmentation with a scalable message-driven microservice architecture, built around my messaging system MessageNX.

About Clip Away

Clip Away is designed to make background removal fast, accurate, and scalable. Using the U²-Net model, the system performs high-quality salient object detection and automatically separates foreground objects from their backgrounds with remarkable precision.

The goal was not only to build an AI-powered tool, but also to design an architecture capable of handling large-scale image processing workloads efficiently.

Architecture Overview

At the heart of the system lies MessageNX, which orchestrates the asynchronous communication between services.

The workflow is designed as follows:

1. Client Interaction

Users upload images through the Clip Away API Gateway.

The gateway manages authentication, request routing, and rate limiting to protect backend services.

2. Producer Microservice

Incoming image-processing requests are sent to a producer microservice, which prepares the job payload.

The job is then published to MessageNX, ensuring the system remains fully asynchronous and decoupled.

3. MessageNX Messaging Core

MessageNX acts as the central message broker that powers the platform.

Inside this layer:

Requests are received by the MessageNX broker

Jobs are placed into the MessageNX Queue

The system polls messages dynamically based on processing thresholds

Queue management ensures balanced load distribution and backpressure control

This messaging layer allows Clip Away to scale horizontally without tightly coupling compute services.

4. Consumer Microservice (AI Processing Layer)

Consumer services poll jobs from the queue and process images using the U²-Net deep learning model:

The model performs salient object detection

The foreground object is extracted

Background pixels are removed to produce a clean transparent image

A local queue buffer is used to optimize job intake and ensure GPU/compute resources remain efficiently utilized.

5. Storage and Result Delivery

Once processing is complete:

The resulting image is stored

The database is updated

The client receives the processed background-free image

Why This Architecture Matters

By building Clip Away around MessageNX, the system achieves:

• High-throughput image processing

• Decoupled microservices

• Fault-tolerant job handling

• Scalable AI inference pipelines

This design allows the platform to process large volumes of images without blocking API requests, making it suitable for production-scale workloads.

Closing Thoughts

Today I’m sharing a service I’ve been working on called MessageNX (Project 136).
https://github.com/rohitpidishetty/MessageNX-SDK
MessageNX is a messaging service designed to support asynchronous communication between applications and services. The idea behind it is simple: provide a lightweight API that allows systems to send tasks or messages and have them processed by background consumers using a producer-consumer model.

The service is intended for scenarios such as background job processing, distributed workloads, and microservice communication, where decoupling components and handling tasks asynchronously becomes important for scalability.

To make integration easier for developers, MessageNX also provides SDK support in multiple languages, including:

• Java
• C #
• Node.js
• Python

This allows applications built in different ecosystems to interact with the service and participate in the same messaging workflow.

The goal with MessageNX is not to replace existing large-scale messaging platforms, but to provide a simple and developer-friendly messaging layer that can be integrated quickly when asynchronous task handling is needed.

More updates and improvements will continue as the project evolves.

Excited to share my new project: Link Condenser - Base 62 URL Shortener 🚀https://url-az.web.app/

I designed and built a scalable URL shortening system inspired by real-world system design patterns used at Big tech companies.

Architecture Overview
The system follows a production-grade design:

Client → Load Balancer → API Gateway → Condenser Service → Cache → Database
🔐 Key Components
✅ API Gateway
Central entry point
Authentication & authorization
Rate limiting (Token Bucket algorithm)
✅ Load Balancer
Distributes traffic across instances
Ensures high availability
✅ Condenser Service
Generates unique Base62 short IDs
Handles redirection logic
Optimized for minimal DB reads
✅ Cache Layer
Frequently accessed URLs served from cache
Reduces database load
Improves latency significantly
✅ Database
Persistent mapping of short → long URLs
Designed for scalability

⚙️ Technical Highlights
Base62 encoding for compact and collision-resistant short URLs
Rate limiting using Token Bucket
Optimized read-heavy design
Horizontally scalable architecture
Designed with cloud-native deployment in mind
This project strengthened my understanding of:
API Gateway patterns
Distributed system design
Caching strategies
Traffic management & throttling
Designing for scalability and reliability
Building systems like this helps bridge the gap between coding problems and real-world backend engineering.
Would love feedback from backend engineers and system design enthusiasts 🙌

Watch full video on youtube: https://www.youtube.com/watch?v=3lEFxAgAUN4

🚀 New to development tools? Confused between CLI and GUI? This video is for you!

In this video, I introduce ITTaHub and walk you through a complete comparison between the CLI (Command Line Interface) version and the GUI (Graphical User Interface) version - so you can choose what works best for you as a student developer.

Whether you're just starting your journey in:

Programming 💻
Software Development 🧠
Open Source 🌐
Dev Tools & Automation ⚙️

Understanding how to work with both CLI and GUI tools is a must-have skill in the real world.

🎓 What You’ll Learn in This Video:
What is ITTaHub?
Why students should start using developer tools early
ITTaHub CLI – Speed, automation & real dev workflow
ITTaHub GUI – Ease of use & visual interaction
CLI vs GUI – Which one should YOU use as a student?
Real-world use cases for projects, assignments & learning
How ITTaHub can improve your productivity and workflow

💡 If you're a student aiming to:
✔ Build real-world projects
✔ Learn industry-standard tooling
✔ Improve development workflow
✔ Transition from beginner to pro

Then getting comfortable with tools like ITTaHub (especially CLI) will give you a huge advantage.

📌 Start using ITTaHub in your academic projects and explore both CLI and GUI to find your ideal development style.

👍 Like | 💬 Comment | 🔔 Subscribe for more developer tools & student-focused tech content!

I had the opportunity to deliver a webinar on Technology Readiness Levels (TRL) and Technology Transfer as part of ITTacademy’s academic outreach initiatives.

During this session, I spoke with students about the evolving landscape of the software industry and highlighted the key distinctions between Computer Science and Software Engineering, with a particular focus on how young aspiring engineers can strategically prepare themselves to meet the expectations of the Software Industry in 2026 and beyond. We had an engaging discussion around industry readiness, practical skill development, and the mindset required to successfully transition from academic learning to real-world engineering environments.

I would like to sincerely thank Dr. MARAM ASHOK (Principal) and Dr. Sateesh Nagavarapu (Dean) & Dr.J Gladson Maria Britto (HOD) for providing me with this opportunity to interact with such enthusiastic learners. Their forward-thinking vision and continued commitment toward student development truly reflect their dedication to empowering the next generation of technology professionals.

Their forward-thinking vision and continued commitment toward student development truly reflect their dedication to empowering the next generation of technology professionals.

Speaking to the students not just as a guest, but as their senior from the 2018–2022 batch, brought back countless memories and made the entire experience truly nostalgic. From once sitting on those very classroom benches as a student to now delivering a webinar from the United States this full-circle moment is something that feels surreal and honestly beyond words.

Looking forward to many more such meaningful academic interactions through ITTacademy.

hashtag