DEV Community: Samruddhi Nikam

Scaling the Future: Architecture of an Event-Driven "Student Success" Cloud

Samruddhi Nikam — Sat, 28 Mar 2026 11:48:21 +0000

In 2026, a "good" app isn't just one that works; it’s one that scales. As first-year Computer Engineering students at SPPU, we are moving past the "Monolith"—where one big program handles everything—to Event-Driven Microservices. This is the high-performance architecture powering the world’s most resilient cloud platforms.
1. The Death of the "Wait" (Asynchronous Processing)
In a traditional app, when a student scans a QR code for attendance, the app "waits" for the database to update before showing a success message. In an Event-Driven Architecture (EDA), the scan triggers an "Event."
The Producer: The mobile app sends a "Scan Event" to a message broker (like Apache Kafka or AWS EventBridge).
The Consumers: Multiple small services (Microservices) "listen" for that event. One updates attendance, another sends a push notification, and a third updates the teacher’s dashboard—all at the same time.
2. Serverless: Code Without Servers
By using Serverless Computing (like AWS Lambda or Google Cloud Functions), we don't have to manage hardware.
Scale-to-Zero: If no students are using the app at 3:00 AM, our cloud cost is zero.
Infinite Scaling: During a 9:00 AM lecture when 500 students scan simultaneously, the cloud automatically creates 500 tiny "instances" of our code to handle the load in parallel.
3. Application: The Student Success "Nervous System"
For our Student Success Ecosystem, this architecture is vital.
Low Latency: Students get instant feedback on their screens.
Fault Tolerance: If the "Notification Service" fails, the "Attendance Service" still works perfectly. The system is "decoupled," meaning one broken part doesn't kill the whole app.
Data Integrity: Using a "Dead Letter Queue," we ensure that even if the internet drops, the attendance event is saved and retried later.
The Competitive Edge
The difference between a student project and a professional product is Reliability. By mastering Event-Driven design, we are building systems that are prepared for the "Real World"—where data is messy, traffic is unpredictable, and failure is not an option.

The Black Box of Privacy: Unlocking "Confidential Computing" in AI

Samruddhi Nikam — Sat, 28 Mar 2026 11:41:32 +0000

As we develop data-heavy platforms like the Student Success Ecosystem, we face a critical engineering dilemma: How do we process private user data in the cloud without exposing it to the service provider? The answer is Confidential Computing—a hardware-based security paradigm that protects data while it is being processed.
1. The Three States of Data Security
In traditional cybersecurity, we protect data in two ways:
Data at Rest: Encrypted on the hard drive.
Data in Transit: Encrypted while moving over the network (HTTPS/TLS).
The Missing Link (Data in Use): Traditionally, data must be decrypted in the RAM to be processed by the CPU. This is where it is most vulnerable to memory-scraping attacks.
2. The TEE (Trusted Execution Environment)
Confidential Computing uses a hardware-level "Enclave" called a Trusted Execution Environment (TEE). Think of it as a secure vault inside the CPU (like Intel SGX or AMD SEV).
Isolation: The CPU creates a private memory space that is invisible to the Operating System, the Hypervisor, and even the Cloud Administrator.
Attestation: The system provides a digital "proof" that the code running inside the vault hasn't been tampered with.
3. Application: Privacy-First AI for Students
In our Student Success Ecosystem, we handle sensitive academic and personal data. By using Confidential Computing, we can:
Run AI models on a student's private data to generate personalized study plans.
Ensure that the raw data is never visible to the server admins.
Meet strict global privacy standards (like GDPR) automatically at the hardware level.
The Engineering Responsibility
In 2026, "Security by Design" is the only way forward. As Computer Engineers at SPPU, our goal is to move beyond software firewalls and start building Hardware-Rooted Trust. The future of the internet isn't just about being fast; it’s about being provably secure.

The Silicon Brain: Why Neuromorphic Computing is the Future of AI

Samruddhi Nikam — Sat, 28 Mar 2026 10:21:06 +0000

As we study traditional Von Neumann architecture at SPPU, a new contender is rising. In 2026, the limitation of AI isn't just the code; it’s the hardware. Neuromorphic Computing is the engineering answer to the energy crisis of modern AI, replacing standard processors with "Spiking Neural Networks" (SNNs) that act like human neurons.
1. What is Neuromorphic Engineering?
Traditional chips move data constantly between the memory and the processor, which wastes a huge amount of energy (known as the Von Neumann Bottleneck). Neuromorphic chips, like Intel's Loihi or IBM's TrueNorth, co-locate memory and processing.
The "Spike" Logic: Unlike standard AI which is always "on," neuromorphic neurons only fire (or "spike") when they receive a specific input.
The Result: They consume up to 1,000 times less power than a traditional GPU.
2. Event-Driven Intelligence
Because these chips only process "events," they are incredibly fast at reacting to the real world.
Standard Camera: Takes 30-60 frames per second, even if nothing is moving.
Neuromorphic (Event-based) Camera: Only records pixels that change.
For us as engineers, this means building drones that can dodge a flying object in microseconds or sensors that can run for years on a single tiny battery.
3. Application: The "Student Success" Edge
In our project, the Student Success Ecosystem, we can imagine a wearable "Tutor Bot" powered by a neuromorphic chip. Because it consumes so little power, it could stay on 24/7, using "on-device" learning to adapt to a student's speech patterns and study habits without ever needing to upload data to a privacy-risky cloud.
The Engineering Paradigm Shift
The future of Computer Engineering isn't just about writing better Python scripts. It’s about designing Hardware-Software Co-Design systems. As the "Silicon Brain" becomes a reality, our role is to bridge the gap between biological inspiration and digital executi

The AGI Horizon: From Tools to Teammates in the Future of Engineering

Samruddhi Nikam — Sat, 28 Mar 2026 10:16:02 +0000

As we sit in our labs at SPPU in 2026, we are no longer just "using" AI; we are collaborating with it. The roadmap from specialized AI to Artificial General Intelligence (AGI) is being written right now, and for a first-year Computer Engineer, this isn't just a trend—it's the defining shift of our entire career.
1. The Death of the "Prompt": Emergence of Intuitive AI
In the early 2020s, we had to learn "Prompt Engineering." By the end of this decade, that skill will be obsolete. Future AI systems will operate on Intent Recognition. Instead of writing complex instructions, the AI will observe our workflow in the IDE, understand the project's constraints (like the memory limits of a Student Success App), and proactively suggest architectural changes.
2. AGI and the "Generalist" Engineer
We often hear that AI will replace coders. The truth is more nuanced: AI will replace syntax-checkers, but it will empower Problem Solvers. AGI—AI that can perform any intellectual task a human can—means that the value of an engineer shifts from knowing the code to designing the system.
The Past: Master one language (Python/C++).
The Future: Master the logic of "System Orchestration."
3. Life in 2030: The "Super-Individual"
Imagine working on a project like the Goda Tech Challenge in 2030. An AGI agent doesn't just help you write a script; it:
Conducts its own real-time satellite research on deforestation.
Drafts the legal compliance documents for the project.
Simulates the 50-year environmental impact of your solution in seconds.
This creates the "Super-Individual"—one engineer with the productivity of an entire 20th-century department.
The Ethical Guardrail
As we move toward AGI, our role at SPPU is to ensure Alignment. We must build "Human-in-the-Loop" systems where the AI's autonomy is guided by human ethics and local context. The future of AI isn't a replacement for human intelligence; it is an infinite expansion of it.

From LLMs to LWMs: The Shift Toward "Large World Models"

Samruddhi Nikam — Sat, 28 Mar 2026 10:13:02 +0000

By 2026, the tech industry has realized that text is not enough. To truly understand the human experience, AI needs to "see" and "feel" the physical world. As first-year Computer Engineering students at SPPU, we are transitioning from Large Language Models (LLMs) to Large World Models (LWMs).
1. What is a "World Model"?
A Large Language Model predicts the next word in a sentence. A Large World Model predicts the next state of a physical environment. By training on millions of hours of video and sensor data, these models develop an internal "understanding" of physics—gravity, collisions, and spatial depth.
2. The Technical Core: Tokenizing Reality
The breakthrough in LWMs comes from Spatio-Temporal Tokenization.
Classic AI: Sees an image as a static grid of pixels.
World Model: Breaks a video stream into "space-time patches." This allows the AI to predict how a ball will bounce or how a student moves through a corridor before it even happens.
3. Application: The "Student Success" Spatial Intelligence
In our project, the Student Success Ecosystem, we can apply LWM logic to create Spatial Intelligence. Instead of just scanning a QR code for attendance, an LWM-powered system can:
Recognize the physical context of a laboratory.
Monitor if safety protocols (like wearing lab coats) are being followed.
Provide real-time, augmented reality (AR) guidance to a student struggling with a hardware circuit.
The Future of Engineering
The engineers of the future won't just feed data into a black box. We will build systems that have a "physical common sense." Whether it’s for deforestation monitoring in the Goda Tech Challenge or managing a smart campus, LWMs are the eyes and ears of 2026’s infrastructure.

The Quantum Countdown: Engineering a "Post-Quantum" World

Samruddhi Nikam — Sat, 28 Mar 2026 10:09:26 +0000

By 2026, the conversation in Computer Engineering has shifted from "If" quantum computers will break our encryption to "When." For us as students at SPPU, understanding the transition to Post-Quantum Cryptography (PQC) is no longer optional—it is a matter of global digital sovereignty.
1. The Vulnerability of Today’s Logic
Most of our current security relies on the difficulty of factoring large prime numbers (RSA) or solving discrete logarithms. While these are impossible for classical computers to solve in a human lifetime, Shor’s Algorithm allows a sufficiently powerful quantum computer to crack them in minutes.
2. Lattice-Based Cryptography: The New Shield
How do we fight a quantum computer? We use math that even quantum bits (qubits) struggle with. The leading candidate is Lattice-Based Cryptography.
The Concept: Instead of simple prime numbers, we hide data within complex, multi-dimensional geometric structures called "lattices."
The Challenge: Finding the "shortest vector" in a high-dimensional lattice is a problem so computationally heavy that it remains secure against both classical and quantum attacks.
3. Engineering for "Harvest Now, Decrypt Later"
You might ask, "Why care now if quantum computers aren't fully here?" The threat is HNDL (Harvest Now, Decrypt Later). Adversaries are stealing encrypted data today, waiting for the day a quantum computer can unlock it. As we build systems like the Student Success Ecosystem, we must consider "Crypto-Agility"—the ability to swap out old encryption for PQC without rebuilding the entire app.
The Bottom Line
The next decade of engineering will be defined by a race between quantum power and cryptographic innovation. Our role is to ensure that the "Student Success" of tomorrow isn't compromised by the technology of the future.

The Rise of the Agent: Moving from Chatbots to Autonomous Engineering

Samruddhi Nikam — Sat, 28 Mar 2026 10:03:43 +0000

In 2025, we talked to AI. In 2026, we are building AI that acts. As Computer Engineering students at SPPU, we are witnessing the transition from Generative AI (which creates content) to Agentic AI (which executes workflows). This isn't just a software update; it’s a fundamental shift in how we design systems.

What is an "Agentic" System? Unlike a standard LLM that waits for a prompt, an AI Agent is designed to achieve a goal. It can break a complex problem into sub-tasks, use external tools (like a Python interpreter or a web scraper), and self-correct when it hits an error.
The Logic of Autonomy: The "Reasoning Loop" The core of an agent is the Reasoning Loop. It follows a pattern of Plan -> Act -> Observe -> Reflect.
- Plan: The agent determines the steps needed.
- Act: It executes a command (e.g., writing a script to analyze a dataset).
- Observe: It checks the output for errors.
- Reflect: It decides if the goal was met or if it needs to try a different approach.
Application: The Student Success Ecosystem In our project, the Student Success Ecosystem, Agentic AI changes everything. Instead of a student searching for a timetable, an "Agent" can:
- Identify a gap in the student's schedule.
- Cross-reference it with pending lab assignments.
- Suggest an optimized study window.
- Automatically set a reminder. The Engineering Responsibility With autonomy comes the need for Guardrails. As we develop these agents, our role as engineers is to ensure they operate within safe, ethical, and predictable boundaries. The future belongs to those who can build AI that doesn't just talk, but "does."

The Invisible Symphony: Mastering Cyber-Physical Systems (CPS) in 2026

Samruddhi Nikam — Sat, 28 Mar 2026 09:05:03 +0000

In the early days of computing, "software" and "hardware" lived in separate worlds. Today, that boundary has vanished. As first-year engineers at SPPU, we are entering an era where code doesn’t just move data—it moves the physical world. This is the domain of Cyber-Physical Systems (CPS).

What makes a system "Cyber-Physical"? A CPS is not just a computer connected to a machine. It is a seamless integration of computation, networking, and physical processes. Think of an autonomous vehicle or a smart power grid. These systems use feedback loops where physical processes affect computations and vice versa.
The Engineering Challenge: Determinism vs. Best-Effort In standard software development, we often settle for "best-effort" speed. But in CPS, timing is correctness.
- Standard Code: If a web page loads in 2 seconds instead of 1, it’s a minor lag.
- CPS Code: If an automated braking system calculates a trajectory 0.5 seconds late, the system fails. As we study Python and Linear Algebra, we aren't just learning syntax; we are learning the mathematical models required to predict these physical behaviors with absolute precision.
From Theory to Lab: The Student Ecosystem In our project, the Student Success Ecosystem, we see the early stages of CPS. By integrating biometric scanning (physical) with AI-driven attendance logic (cyber), we create a system that reacts to the physical presence of a student in real-time. This is the foundation for the "Smart Cities" we will build as future graduates. The Bottom Line The next generation of Computer Engineers won't just be "coders." We will be System Architects who understand the friction of the physical world and the logic of the digital one. The future is hybrid.

The Green Code: Why Sustainable Software is the Next Engineering Revolution

Samruddhi Nikam — Sat, 28 Mar 2026 08:50:19 +0000

As engineering students in 2026, we are often taught how to make code "fast" or "secure." But there is a new metric that is becoming just as important: Carbon Efficiency. Every line of code we write has a physical footprint.

What is "Green Software"? "Green software" isn't about the hardware; it’s about writing algorithms that require less computational power, thereby reducing the energy consumption of data centers. For example, moving from a brute-force search to an optimized O(\log n) algorithm doesn't just save time—it saves electricity.
Lessons from the Goda Tech Challenge Working on issues like deforestation taught me that technology isn't just a tool for monitoring the environment; it must also be a part of the environment. If we build massive AI models to track trees but those models consume megawatts of power, are we really winning?
The "Student Success" Approach to Sustainability In my recent project, the Student Success Ecosystem, I realized that efficiency is the key to sustainability. By using lightweight Python scripts and local data processing, we can:
- Minimize battery drain on student mobile devices.
- Reduce the frequency of server pings.