Forem: Manas Uniyal

🧠 Google Just Solved a Big Problem for AI Coding Assistants (Explained Simply)

Manas Uniyal — Fri, 27 Feb 2026 07:30:17 +0000

FEB 2026 — Google announced something that could quietly change how developers use AI tools.

If you’ve ever asked an AI assistant about Firebase, Android, or Google Cloud and received a confusing or outdated answer… this is exactly what Google is trying to fix.

🤔 The Problem: AI Doesn’t Always Know the Latest Docs

AI tools (like coding assistants, CLIs, or agent platforms) rely on the data they were trained on.

That means:

They might not know new features

They might give outdated solutions

They might guess incorrectly

Example:

You ask:

“How do I implement push notifications in Firebase?”

AI might respond using old methods.

Not ideal.

💡 Google’s Solution: Let AI Read Official Docs Directly

Google introduced two tools that allow AI systems to access official developer documentation in real time.

Instead of guessing…

👉 AI can now check the source.

🛠️ Tool #1 — Developer Knowledge API

Think of this as a search engine for Google’s developer documentation.

Developers and AI tools can:

Search official docs

Retrieve full documentation pages

Get information in a clean format

It covers sources like:

Firebase docs

Android developer docs

Google Cloud docs

And the content is updated within about a day of any changes.

So tools stay current.

🤖 Tool #2 — MCP Server (Model Context Protocol Server)

This is where it gets really interesting.

The MCP server lets AI assistants connect directly to Google documentation.

So your AI tool can:

📖 Read docs before answering you

Like giving the AI an open book during an exam.

🌍 What This Means in Real Life

Before:

AI answers from memory ❌

Now:

AI checks official docs first ✅

Example questions AI can answer better:

“What’s the best way to implement Firebase push notifications?”

“How do I fix this Google Maps API error?”

“Should I use Cloud Run or Cloud Functions?”

🚀 Why This Matters for Developers

This could make AI coding tools:

More accurate

More reliable

More useful for debugging

Better for learning new technologies

In the future, developers might rely less on manual documentation searching and more on AI that reads docs for them.

🧾 In Simple Words

Google built a system that allows AI assistants to read official documentation in real time, so developers get correct and up-to-date help instead of outdated guesses.

🌱 Final Thoughts

This is one of those updates that doesn’t look flashy but could significantly improve developer workflows — especially as AI tools become part of everyday coding.

If you use Google technologies, expect your AI assistants to become smarter and more trustworthy soon.

🌩️ How to Get AWS Certifications for Free in 2025 💸

Manas Uniyal — Sat, 05 Apr 2025 16:56:22 +0000

(Yes, totally free — no sketchy tricks!)

So here’s the deal — AWS certifications are a big deal in the tech world right now. Whether you're a student 👨‍🎓 trying to land your first internship, a developer 👩‍💻 looking to level up, or someone exploring cloud for fun — getting certified can really boost your career.

But yeah... those exams? Kinda pricey.
So let me show you how to get those AWS certifications for FREE in 2025 — using legit ways that actually work. Ready? Let’s go. 🚀

🌟 1. Use AWS Skill Builder — the Official Free Learning Hub
AWS Skill Builder is like the Netflix of cloud courses — except it’s official and many parts are totally free.
`

Here’s what’s cool about it:

📚 Certification prep courses for every level

🧠 Cloud Quest — a super fun, game-like way to learn cloud

💬 Practice questions + learning badges

🎁 Sometimes they give out free exam vouchers just for completing stuff`

💡 Pro tip: Sign up, explore the learning paths, and turn on email notifications — AWS sends voucher links from time to time!

🎓 2. If You’re a Student, Don’t Miss AWS Educate
AWS Educate is specifically for students and beginners, and it's pretty generous.

What you get:

🆓 Foundational cloud learning (no prior experience needed)

⚡ Free AWS credits to practice on real cloud services

🎯 Sometimes even certification vouchers pop up

Just use your .edu or college email to register — it helps you get verified faster. If you're in college right now, this one’s a no-brainer.

🎉 3. Join AWS Events — They Love Giving Out Freebies
This is a fun one!
AWS runs events all year long, both online and offline. Some examples:

🌐 AWSome Day

🔥 re:Invent

🇮🇳 India-specific events like Build On India

These usually include:

🧑‍🏫 Free workshops and learning sessions
🎟️ Vouchers or discounts on certifications
🧪 Early access to beta exams (sometimes 100% free!)

📌 Keep checking the AWS Events Page or follow them on LinkedIn to stay in the loop.

🏫 4. Ask Your College About AWS Academy
If your college is part of AWS Academy, you're in luck.

What it means:

You’ll get trained using AWS’s official curriculum

You may get a voucher to take the exam for free

You can add a shiny badge to your resume at no cost 😍

👉 Just ask your college placement cell or IT department — “Are we enrolled in AWS Academy?” Simple.

🥇 5. Join AWS Certification Challenges
Every few months, AWS runs fun challenges where you can:

🔐 Complete a set of learning tasks

🧠 Pass knowledge checks

🎁 Get a free exam voucher at the end

Some examples:

Get AWS Certified Challenge

She Builds CloudU (focused on empowering women in cloud)

Build On India (region-specific opportunities)

They’re limited-time, so keep an eye on the AWS Community or their newsletters.

🧰 6. GitHub Student Developer Pack = Free Credits
If you're a student developer and not using the GitHub Student Pack yet... what are you doing? 😅

Here’s what you get:

💵 Free AWS credits to try services

🛠️ Tools like GitHub Copilot, Namecheap domains, and more

Okay, it doesn’t give you cert vouchers, but it does give you what you need to practice for the exam — and that’s half the battle.

🧑‍💼 7. Already Working Somewhere? Ask Your Company to Cover It
This might surprise you, but tons of companies are willing to pay for your AWS cert if you ask.

Here’s what to do:

Ask HR if there’s a learning or certification budget

Join an internal cloud upskilling program if they have one

Pass the exam and show the bill — many companies will reimburse

Trust me, companies love when employees grow — and AWS certs are great bragging rights for them too 😄

🔍 8. Look Out for Coursera & LinkedIn Campaigns
Sometimes AWS partners with platforms like:

Coursera

LinkedIn Learning

FutureLearn

During special campaigns, they offer:

📘 Free AWS courses

🎓 Completion-based vouchers or discounts

📲 Follow AWS on LinkedIn and keep checking your email for these surprise opportunities — they pop up a few times a year.

🧠 Bonus: Free Resources to Help You Pass
Once you get your voucher, don’t just wing it.
Here are some amazing (and free!) prep resources:

✅ Tutorials Dojo – practice tests that feel real

✅ ExamTopics – community-driven Q&A

✅ YouTube channels like freeCodeCamp, Tech with Lucy, and AWS with Vishal

🧩 Combine real practice + learning paths + mock exams = you’re ready to crush it 💪

✨ Final Words (from someone who's been there)
Getting an AWS cert in 2025 doesn’t have to be expensive. In fact, you can totally do it for free if you plan smart and grab the right opportunities.

So, whether you’re going for:

Cloud Practitioner (great for beginners)

Solutions Architect (for builders and devs)

or anything in between...

Just start.
💻 Sign up, learn at your own pace, look out for vouchers, and keep building.

You’ve got this. ☁️🔥

Building a Robust Backend: From Fundamentals to Deployment

Manas Uniyal — Wed, 02 Apr 2025 16:00:50 +0000

Building a Robust Backend: From Fundamentals to Deployment

Introduction

Welcome to the world of backend development! Behind every sleek website or app lies a powerful backend, the unsung hero handling data, logic, and user interactions. This guide will walk you through the essential concepts and practical steps to build a robust backend, from understanding the basics to deploying your application.

HTTP, DNS, IPs & Networks

The foundation of web communication is HTTP (Hypertext Transfer Protocol). DNS (Domain Name System) translates human-readable domain names into IP addresses, which are numerical labels assigned to devices on a network.

JavaScript

// Example: Making an HTTP GET and POST request using Node.js (axios)
const axios = require('axios');

axios.get('https://api.example.com/data')
.then(response => {
console.log("GET Response:", response.data);
})
.catch(error => {
console.error("GET Error:", error);
});

axios.post('https://api.example.com/data', { item: 'new item' })
.then(response => {
console.log("POST Response:", response.data);
})
.catch(error => {
console.error("POST Error:", error);
});

APIs: The Backend’s Messenger

APIs (Application Programming Interfaces) enable communication between different software applications. They define how requests and responses are structured.

Types of APIs

REST (Representational State Transfer): Uses standard HTTP methods (GET, POST, PUT, DELETE).
GraphQL: Allows clients to request specific data.
JavaScript

// Example: Basic REST API endpoint (Express.js) with POST route
const express = require('express');
const app = express();

let users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];

app.get('/api/users', (req, res) => {
res.json(users);
});

app.post('/api/users', express.json(), (req, res) => {
const newUser = { id: users.length + 1, ...req.body };
users.push(newUser);
res.status(201).json(newUser);
});

Backend Languages

Popular backend languages include Node.js, Python, Java, Ruby, and Go. Each has its strengths and weaknesses.

Databases: The Backbone of Your Backend

Databases store and manage data. Options include relational databases (MySQL, PostgreSQL) and NoSQL databases (MongoDB).

JavaScript

// Example: Connecting to MongoDB (Mongoose) and creating a document
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydatabase', {
useNewUrlParser: true,
useUnifiedTopology: true,
})
.then(() => console.log('MongoDB Connected'))
.catch(err => console.log(err));

const userSchema = new mongoose.Schema({
name: String,
email: String,
});

const User = mongoose.model('User', userSchema);

async function createUser(name, email) {
const user = new User({ name, email });
await user.save();
console.log("User Saved");
}

createUser("Charlie", "Charlie@email.com");

Backend Architectures

Monolithic: All components are tightly coupled.
Microservices: Independent services communicate via APIs.

Demo and Setup Tools & 8. Setup

This typically involves installing Node.js, npm, a code editor (VS Code), and MongoDB.

Create Express Server

JavaScript

// Example: Creating an Express server and adding middleware
const express = require('express');
const app = express();
const bodyParser = require('body-parser');

app.use(bodyParser.json()); // for parsing application/json

app.listen(3000, () => {
console.log('Server listening on port 3000');
});

Config

Configuration files store environment-specific settings.

Routes

Routes define how the server responds to different HTTP requests.

JavaScript

// Example: POST route to create a user with validation
app.post('/api/users', express.json(), (req, res) => {
const { name, email } = req.body;
if (!name || !email) {
return res.status(400).json({ error: 'Name and email are required' });
}
// Save to database...
res.status(201).json({name, email});
});

MongoDB

MongoDB is a NoSQL database that stores data in JSON-like documents.

Models

Models define the structure of data in the database.

JavaScript

// Example: Mongoose model with validation
const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
name: { type: String, required: true },
email: { type: String, required: true, unique: true },
});

const User = mongoose.model('User', userSchema);

Error Handler

Centralized error handling ensures consistent error responses.

JavaScript

//Example Error Handler
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).json({error: 'Something broke!'});
});

Authentication

Verifying user identities (e.g., using JWT).

JavaScript

// Example: JWT authentication with middleware
const jwt = require('jsonwebtoken');

function authenticateToken(req, res, next) {
const authHeader = req.headers['authorization'];
const token = authHeader && authHeader.split(' ')[1];
if (token == null) return res.sendStatus(401);

jwt.verify(token, 'secretkey', (err, user) => {
if (err) return res.sendStatus(403);
req.user = user;
next();
});
}

app.get('/protected', authenticateToken, (req, res) => {
res.json({ message: 'Protected route accessed by user', user: req.user });
});

const token = jwt.sign({ userId: 123 }, 'secretkey');

Authorization

Controlling user access to resources based on roles.

Arcjet

Arcjet helps protect APIs from abuse and bots.

Subscriptions

Implementing subscription-based features.

Reminder Workflow

Automating tasks and sending reminders using tools like cron jobs or message queues.

Send Emails

Integrating email functionality using libraries like Nodemailer.

JavaScript

// Example: Sending an email using Nodemailer with HTML content
const nodemailer = require('nodemailer');

const transporter = nodemailer.createTransport({
service: 'gmail',
auth: {
user: 'your_email@gmail.com',
pass: 'your_password',
},
});

const mailOptions = {
from: 'your_email@gmail.com',
to: 'recipient@example.com',
subject: 'Hello from Node.js',
html: 'This is a test email with HTML!',
};

transporter.sendMail(mailOptions, (error, info) => {
if (error) {
console.error(error);
} else {
console.log('Email sent: ' + info.response);
}
});

VPS Hosting & Deployment

Deploying the backend to a VPS (e.g., AWS EC2, DigitalOcean Droplets).

This post provides a foundational overview of backend development. Each topic can be explored in much greater depth. Remember to adapt code examples to your specific needs and technologies.

Caching & Performance Optimization in Node.js & React

Manas Uniyal — Sat, 29 Mar 2025 16:13:44 +0000

Caching & Performance Optimization in Node.js & React

Optimizing performance is crucial for modern applications to ensure fast load times and smooth user experiences. This post explores three key techniques for improving performance:

Caching with Redis – Reducing database load and speeding up responses.
Compression (Middleware) – Decreasing response size for faster transmission.
Lazy Loading & Code Splitting – Enhancing front-end performance by loading resources efficiently.

1. Caching Responses with Redis

Architecture:

User Request → Node.js Server → Check Redis Cache → (Cache Hit? Serve Data) : (Cache Miss? Fetch from DB & Store in Cache)

Cache Hit: If the requested data is already cached in Redis, it is served directly, reducing latency and database load.
Cache Miss: If the data is not found in Redis, the server fetches it from the database, caches it for future use, and sends the response.

Why Use Caching?

Reduces database queries and computation time.
Speeds up response times significantly.
Enhances scalability by offloading traffic from the database.

Setting Up Redis in Node.js

Step 1: Install Redis & Node.js Client

npm install redis

Step 2: Connect Redis to Node.js

const redis = require('redis');
const client = redis.createClient();

client.on('error', (err) => console.error('Redis Error:', err));

client.connect().then(() => console.log('Connected to Redis'));

Step 3: Implement Caching

const express = require('express');
const app = express();

app.get('/data', async (req, res) => {
    const cacheKey = 'myData';
    const cachedData = await client.get(cacheKey);

    if (cachedData) {
        return res.json(JSON.parse(cachedData));
    }

    // Simulating DB fetch
    const data = { message: 'Fetched from DB', timestamp: Date.now() };
    await client.setEx(cacheKey, 3600, JSON.stringify(data)); // Store for 1 hour
    res.json(data);
});

app.listen(3000, () => console.log('Server running on port 3000'));

Best Practices for Redis Caching

Set an expiration time (TTL) for cached data to prevent stale responses.
Use consistent cache keys for structured retrieval.
Implement cache invalidation when data updates to avoid serving outdated information.
Monitor Redis usage to prevent memory overflows.

2. Compression Middleware for Faster Responses

Architecture:

User Request → Express Middleware (Compression) → Compressed Response Sent → Faster Load Time

Why Use Compression?

Reduces response size significantly.
Decreases bandwidth usage.
Improves page load speed by minimizing payload size.

Setting Up Compression in Express

Step 1: Install Compression Middleware

npm install compression

Step 2: Integrate Compression

const compression = require('compression');
app.use(compression());

How It Works?

The middleware automatically compresses responses using GZIP.
Compresses JSON, HTML, CSS, and JavaScript before sending to the client.
Reduces response payload size by up to 70%, leading to faster page rendering.

Best Practices for Compression

Enable Brotli compression, which is more efficient than GZIP.
Compress static assets using tools like Webpack or Gzip.
Use Content-Encoding headers to ensure proper decompression by clients.

3. Lazy Loading & Code Splitting (React)

Architecture:

Initial Load → Load Only Essential Code → User Navigates → Dynamically Fetch Remaining Components

Why Use Lazy Loading?

Reduces initial page load time.
Loads components only when needed.
Optimizes performance for large applications.

Using React Lazy Loading

import React, { lazy, Suspense } from 'react';
const Dashboard = lazy(() => import('./Dashboard'));

function App() {
    return (
        <Suspense fallback={<div>Loading...</div>}>
            <Dashboard />
        </Suspense>
    );
}
export default App;

Using Code Splitting with React Router

import { BrowserRouter as Router, Route, Routes } from 'react-router-dom';
import { lazy, Suspense } from 'react';

const Home = lazy(() => import('./Home'));
const Profile = lazy(() => import('./Profile'));

function App() {
    return (
        <Router>
            <Suspense fallback={<div>Loading...</div>}>
                <Routes>
                    <Route path='/' element={<Home />} />
                    <Route path='/profile' element={<Profile />} />
                </Routes>
            </Suspense>
        </Router>
    );
}
export default App;

Best Practices for Lazy Loading & Code Splitting

Split large bundles using dynamic imports.
Use React Suspense to show loading indicators while fetching components.
Prefetch critical resources to prevent delays in navigation.
Utilize Webpack's code splitting features (splitChunks & dynamic imports).

Conclusion

Redis Caching: Reduces load times and database queries by storing responses in memory.
Compression Middleware: Speeds up response times with GZIP/Brotli compression.
Lazy Loading & Code Splitting: Optimizes front-end performance by loading only necessary components when needed.

Implement these techniques to make your applications faster, scalable, and more efficient!

OAuth Authentication: Google, Facebook, GitHub Login via NODE JS (Backend)

Manas Uniyal — Sat, 29 Mar 2025 15:49:21 +0000

OAuth Authentication: Google, Facebook, GitHub Login

OAuth (Open Authorization) is a standard that allows users to log in to your website using third-party accounts like Google, Facebook, or GitHub. It eliminates the need for users to create new accounts, making authentication seamless and secure.

Diagram :

OAuth architecture in Node.js with diagrams and flow
How is perplexity made and its architecture?
Draw architecture of node based authentication using jwt

OAuth is an open-standard authorization framework that enables secure, delegated access to protected resources geeksforgeeks.org. Let's explore its architecture and implementation in Node.js, starting with the core concepts and visualizing the flow.

Why Use OAuth?

No need to store passwords: Users authenticate via trusted providers.
Faster login: No signup form, just a few clicks.
Secure: Reduces risk of password leaks.

Setting Up OAuth in a Node.js Application

We'll set up OAuth authentication using Passport.js, a popular authentication middleware for Node.js.

1. Install Dependencies

npm init -y  # Initialize package.json
npm install express passport passport-google-oauth20 passport-facebook passport-github2 express-session dotenv

2. Project Structure

project-folder/
|-- config/
|   |-- passportSetup.js
|-- .env
|-- server.js

3. Configure Environment Variables

Create a .env file to store OAuth credentials (replace with actual keys from the provider's developer console).

GOOGLE_CLIENT_ID=your_google_client_id
GOOGLE_CLIENT_SECRET=your_google_client_secret
FACEBOOK_CLIENT_ID=your_facebook_client_id
FACEBOOK_CLIENT_SECRET=your_facebook_client_secret
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
SESSION_SECRET=your_session_secret

4. Setting Up Passport Strategies

Create config/passportSetup.js:

const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;
const FacebookStrategy = require('passport-facebook').Strategy;
const GitHubStrategy = require('passport-github2').Strategy;
require('dotenv').config();

const callbackHandler = (accessToken, refreshToken, profile, done) => {
    return done(null, profile);
};

passport.use(new GoogleStrategy({
    clientID: process.env.GOOGLE_CLIENT_ID,
    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    callbackURL: '/auth/google/callback'
}, callbackHandler));

passport.use(new FacebookStrategy({
    clientID: process.env.FACEBOOK_CLIENT_ID,
    clientSecret: process.env.FACEBOOK_CLIENT_SECRET,
    callbackURL: '/auth/facebook/callback',
    profileFields: ['id', 'displayName', 'emails']
}, callbackHandler));

passport.use(new GitHubStrategy({
    clientID: process.env.GITHUB_CLIENT_ID,
    clientSecret: process.env.GITHUB_CLIENT_SECRET,
    callbackURL: '/auth/github/callback'
}, callbackHandler));

passport.serializeUser((user, done) => {
    done(null, user);
});

passport.deserializeUser((user, done) => {
    done(null, user);
});

5. Setting Up Express Server

Create server.js:

const express = require('express');
const passport = require('passport');
const session = require('express-session');
require('./config/passportSetup');
require('dotenv').config();

const app = express();

app.use(session({ secret: process.env.SESSION_SECRET, resave: false, saveUninitialized: true }));
app.use(passport.initialize());
app.use(passport.session());

// Google Auth Routes
app.get('/auth/google', passport.authenticate('google', { scope: ['profile', 'email'] }));
app.get('/auth/google/callback', passport.authenticate('google', { successRedirect: '/dashboard', failureRedirect: '/' }));

// Facebook Auth Routes
app.get('/auth/facebook', passport.authenticate('facebook'));
app.get('/auth/facebook/callback', passport.authenticate('facebook', { successRedirect: '/dashboard', failureRedirect: '/' }));

// GitHub Auth Routes
app.get('/auth/github', passport.authenticate('github', { scope: ['user:email'] }));
app.get('/auth/github/callback', passport.authenticate('github', { successRedirect: '/dashboard', failureRedirect: '/' }));

// Dashboard Route
app.get('/dashboard', (req, res) => {
    res.send(`Hello, ${req.user.displayName}`);
});

// Logout Route
app.get('/logout', (req, res) => {
    req.logout(err => {
        if (err) return next(err);
        res.redirect('/');
    });
});

app.listen(3000, () => console.log('Server running on http://localhost:3000'));

Architecture is :

Understanding OAuth Architecture

OAuth authentication follows a structured flow involving key components:

Core Components:

Resource Owner: The user who owns the protected resources (e.g., Google account holder).

Resource Server: The server hosting the protected resources (e.g., Google's servers).

Client: Your Node.js application requesting access.

Authorization Server: The server that authenticates the user and issues tokens.

Key Elements of Authorization Flow:

Initial Redirect:

When the user clicks the login button, your Node.js app redirects them to the authorization server with:

client_id: Identifies your application.

response_type=code: Requests an authorization code.

redirect_uri: Where the auth server will send the user back after authorization.

Token Exchange:

After receiving the authorization code, your app makes a POST request to exchange it for an access token.

This happens server-side, keeping your credentials secure.

Resource Access:

The final step uses the Bearer token format, meaning the token itself serves as proof of authorization.
Token Expiration: Implement proper token refresh logic
State Validation: Always validate the state parameter to prevent CSRF attacks
Callback URLs: Ensure callback URLs match exactly what's configured in provider settings
Error Handling: Implement proper error handling for failed authentications

This implementation provides secure authentication with Google, Facebook, and GitHub while maintaining proper security practices and token management. Remember to handle errors appropriately and implement proper logging for debugging purposes.

6. Run the Application

node server.js

Visit http://localhost:3000/auth/google to test Google login.
Visit http://localhost:3000/auth/facebook to test Facebook login.
Visit http://localhost:3000/auth/github to test GitHub login.

Conclusion

OAuth authentication simplifies user login and improves security. Using Passport.js, we easily integrated Google, Facebook, and GitHub login into our Node.js application.

Feel free to ask if you have any questions!

IOT-based Smart Ground water Recharge System

Manas Uniyal — Thu, 27 Mar 2025 07:48:52 +0000

🌧️ Smart Rainwater Harvesting System: A Step Towards Sustainable Water Management 💧

Water is the most important commodity for existence of life. In India, the main sources of water are rainwater(monsoon) that fills the rivers with water and underground water. However, we have seen a steady decline in underground water levels across India at an alarming rate that affects the agriculture and daily water needs of the citizens. This paper suggests a smart ground water recharge system that automatically recharges the ground water after rain fall. The system uses smart IOT devices, solar panel, and a filter to filter out unwanted materials that comes along the rainwater. In this paper a fully automatic rainwater harvesting is introduced that collects rainwater and filters out dirt and unwanted materials(trash) that comes along the rain. It also senses acidic content of rain and also filters it out when needed. Later on the filtered water can be directly recharged in ground, or it can also be collected in artificial pools for irrigation purpose. Polluted water can be very harmful for our environment and food cycle [14].

Water scarcity is a pressing issue, and efficient water management is the need of the hour! 🌍 That’s why I, along with my research team, developed a Smart Rainwater Harvesting System, which was recently presented at a prestigious conference. 🎤📜 This project leverages cutting-edge IoT and AI-based technologies to optimize water conservation and usage. Let's dive into the technicalities! 🚀

🌱 The Motivation Behind This Research

Traditional rainwater harvesting systems often lack real-time monitoring, predictive analysis, and automated distribution mechanisms. Our smart system aims to:
✅ Maximize water collection efficiency 📊
✅ Reduce water wastage 🚱
✅ Ensure sustainable groundwater recharge 🌿
✅ Use predictive analytics to optimize storage & usage 📡

🌍 The Role of IoT in Smart Water Management

The Internet of Things (IoT) is at the core of our Smart Rainwater Harvesting System. By integrating smart sensors, microcontrollers, and cloud-based analytics, we ensure seamless automation and remote monitoring. IoT enables:

📡 Real-time data acquisition from multiple sensors
⚡ Automated control of valves and pumps
☁️ Cloud storage & predictive analytics for water usage optimization
📱 Remote access via web or mobile applications

🔧 How Our Smart System Works

Our IoT-driven Rainwater Harvesting System is designed to autonomously monitor and manage rainwater collection using multiple sensors and AI-based decision-making. Here’s how it works:

1️⃣ Data Collection Using Smart Sensors 📡

We integrated multiple sensors into the system to track environmental conditions and water levels in real-time:

🌦️ Rainfall sensors to measure precipitation levels
📏 Ultrasonic sensors to monitor tank water levels
🌡️ Temperature & humidity sensors for climate data analysis
⚡ pH & TDS sensors to ensure water quality

2️⃣ AI-Driven Prediction & Optimization 🧠

Using Machine Learning algorithms, the system predicts:

Expected rainfall based on historical data 📅
Optimal storage strategies to avoid overflow 🌊
Water usage patterns for efficient distribution 🚰

3️⃣ Automated Water Distribution 🚿

Our system uses actuators and smart valves to autonomously distribute collected rainwater based on:
✅ Soil moisture levels (for irrigation) 🌾
✅ Household water needs 🏡
✅ Groundwater recharge requirements 🌎

4️⃣ Cloud-Based Monitoring & Control ☁️

Users can monitor and control the system remotely via a web dashboard or mobile app. 📱 This provides:

Real-time water level alerts 🚨
Historical data trends 📈
Customizable water usage plans 🏗️

🛠️ NodeMCU-Based IoT Implementation

Our system is built using the NodeMCU ESP8266, which connects various sensors and actuators to the cloud for real-time monitoring and automation.

📌 Sample NodeMCU Code for Water Level Monitoring

#include <ESP8266WiFi.h>
#include <FirebaseESP8266.h>

#define TRIG D1
#define ECHO D2
#define WIFI_SSID "Your_WiFi_Name"
#define WIFI_PASSWORD "Your_WiFi_Password"
#define FIREBASE_HOST "your-project.firebaseio.com"
#define FIREBASE_AUTH "your-firebase-auth-key"

FirebaseData firebaseData;

void setup() {
    Serial.begin(115200);
    pinMode(TRIG, OUTPUT);
    pinMode(ECHO, INPUT);
    WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Firebase.begin(FIREBASE_HOST, FIREBASE_AUTH);
}

void loop() {
    digitalWrite(TRIG, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIG, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG, LOW);
    long duration = pulseIn(ECHO, HIGH);
    float distance = duration * 0.034 / 2;
    Serial.print("Water Level: ");
    Serial.println(distance);
    Firebase.setFloat(firebaseData, "water_level", distance);
    delay(5000);
}

🌟 Features of This Implementation

📶 Real-time water level data sent to Firebase for cloud monitoring
🔧 Wireless connectivity using ESP8266 WiFi module
🔄 Automated alerts when water levels are too high or too low

📊 Key Findings & Impact

🔬 Our experiments showed that water utilization efficiency improved by 40% compared to traditional methods.
💰 Cost analysis revealed that integrating smart IoT technology significantly reduces water wastage and improves long-term savings.
🌱 The system also helped in groundwater conservation and improved irrigation planning in agricultural areas.

🔮 Future Scope & Improvements

Although our prototype performed exceptionally well, we aim to enhance it further by:
🔹 Implementing edge AI for faster real-time processing 🚀
🔹 Expanding the system for large-scale industrial applications 🏭
🔹 Integrating blockchain for transparent water management records 🔗

💡 Final Thoughts

This research has been an incredible journey, and seeing our Smart Rainwater Harvesting System recognized at a conference was truly rewarding! 🏆💙 With water scarcity becoming a global crisis, integrating technology with sustainability is the way forward.

What are your thoughts on smart water management systems? Drop your ideas in the comments! 💬😊

SmartWaterManagement #IoT #NodeMCU #ESP8266 #Sustainability #AI #RainwaterHarvesting

When Should TypeScript Be Used Instead of JavaScript?

Manas Uniyal — Thu, 27 Mar 2025 07:39:13 +0000

🚀 When Should You Use TypeScript Instead of JavaScript?

JavaScript is the go-to language for web development, but have you ever found yourself struggling with unexpected bugs or messy code? 🤯 That’s where TypeScript comes to the rescue! TypeScript is a superset of JavaScript that adds static typing, making your life as a developer much easier. But when exactly should you choose TypeScript over JavaScript? Let’s dive in! 👇

1️⃣ Large-Scale Projects

If you're working on a huge application with multiple developers, TypeScript is a game-changer! 💡 With static typing and better code organization, you can avoid those nasty runtime errors and make collaboration smoother. No more “undefined is not a function” surprises! 😅

2️⃣ Strict Type Safety

Ever faced unexpected NaN or undefined errors? 🫠 JavaScript’s dynamic typing can be unpredictable. TypeScript catches errors at compile time, saving you from debugging nightmares later. If your project requires high reliability, TypeScript is your best friend. 🛡️

Example:

function addNumbers(a: number, b: number): number {
  return a + b;
}
console.log(addNumbers(5, "10")); // ❌ Type error at compile time!

3️⃣ Enhanced Developer Experience

TypeScript offers amazing tooling support! 🛠️ With autocomplete, inline documentation, and better refactoring capabilities, coding feels smoother and more intuitive. If you use VS Code, you’ll love how TypeScript makes development faster and more enjoyable! 😍

4️⃣ Object-Oriented Programming (OOP)

If you love working with classes, interfaces, and inheritance, TypeScript has your back. 🏗️ While JavaScript has basic class support, TypeScript takes it up a notch with stricter rules and better OOP implementation. If you’re into enterprise-level applications, this is a must! 🚀

Example:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): string {
    return `Hello, my name is ${this.name} and I am ${this.age} years old.`;
  }
}

const john = new Person("John", 30);
console.log(john.greet());

5️⃣ Seamless Third-Party Library Integration

Ever used an external library and had no clue what parameters to pass? 🤨 TypeScript’s type definitions (@types/* packages) help you understand function signatures and expected data structures, making third-party libraries easier to use and debug. 🔍

6️⃣ Better Code Maintainability & Scalability

Working on a long-term project? 📈 Maintaining JavaScript can be a nightmare as the codebase grows. TypeScript enforces structured and consistent coding practices, making it easier to manage, scale, and refactor your project down the line. 💪

7️⃣ TypeScript for Backend (Node.js)

Node.js developers, listen up! 👂 TypeScript isn’t just for frontend—it's a fantastic choice for backend development too. It helps catch async errors, improve code structure, and boost performance for large-scale server-side applications. ⚡

Example:

import express from 'express';

const app = express();
app.get('/', (req, res) => {
  res.send('Hello, TypeScript in Node.js!');
});

app.listen(3000, () => console.log('Server running on port 3000'));

8️⃣ Migrating & Refactoring Legacy Code

Got an old JavaScript project that's turning into a spaghetti code disaster? 🍝 TypeScript can help gradually clean up and improve your existing codebase without breaking functionality. Perfect for teams looking to enforce better coding practices! 🧹

🤔 When Should You Stick with JavaScript?

Even though TypeScript is awesome, JavaScript is still a great choice in some cases:
✅ Small projects or quick prototypes where strict typing isn’t necessary.
✅ Simple scripts or web pages where adding TypeScript would be overkill.
✅ Performance-sensitive applications where avoiding transpilation is crucial.
✅ Teams unfamiliar with TypeScript, as it comes with a learning curve.

🎯 Final Thoughts

So, should you switch to TypeScript? If you're working on a large, scalable, or critical application, the answer is YES! ✅ TypeScript helps you write safer, cleaner, and more maintainable code while making development a lot more fun. 🎉

But if you're just hacking together a quick project, JavaScript still gets the job done! 💡 The key is to choose what works best for your specific needs and team.

Have you tried TypeScript yet? Let me know your thoughts! 👇😊

Building a Secure Authentication System in Node.js using JWT

Manas Uniyal — Thu, 27 Mar 2025 07:33:14 +0000

Building a Secure Authentication System in Node.js using JWT

Authentication is a crucial aspect of backend development, ensuring secure access to resources. In this tutorial, we'll build a secure authentication system in Node.js using JSON Web Tokens (JWT).

Prerequisites

📌 Basic knowledge of JavaScript and Node.js
📌 Node.js installed on your system
📌 A package manager like npm or yarn

Step 1: Setting Up the Project

First, create a new Node.js project:

mkdir jwt-auth-system
cd jwt-auth-system
npm init -y

This initializes a new Node.js project with a default package.json file.

Next, install the required dependencies:

npm install express jsonwebtoken bcryptjs dotenv cors mongoose

Also, install nodemon for development:

npm install --save-dev nodemon

Step 2: Setting Up Express Server

Create an index.js file and set up a basic Express server:

require('dotenv').config();
const express = require('express');
const mongoose = require('mongoose');
const cors = require('cors');
const authRoutes = require('./routes/auth');

const app = express();
app.use(express.json());
app.use(cors());

mongoose.connect(process.env.MONGO_URI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
})
.then(() => console.log('MongoDB Connected'))
.catch(err => console.log(err));

app.use('/api/auth', authRoutes);

app.listen(5000, () => console.log('Server running on port 5000'));

Step 3: Creating User Model

Create a new folder models and a file User.js inside it:

const mongoose = require('mongoose');

const UserSchema = new mongoose.Schema({
  username: { type: String, required: true, unique: true },
  email: { type: String, required: true, unique: true },
  password: { type: String, required: true }
});

module.exports = mongoose.model('User', UserSchema);

Step 4: Implementing Authentication Routes

Create a routes folder and an auth.js file inside it:

const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const User = require('../models/User');

const router = express.Router();

// 📝 Register
router.post('/register', async (req, res) => {
  try {
    const { username, email, password } = req.body;
    const hashedPassword = await bcrypt.hash(password, 10);
    const newUser = new User({ username, email, password: hashedPassword });
    await newUser.save();
    res.status(201).json({ message: 'User registered successfully' });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// 🔑 Login
router.post('/login', async (req, res) => {
  try {
    const { email, password } = req.body;
    const user = await User.findOne({ email });
    if (!user) return res.status(404).json({ message: 'User not found' });

    const isMatch = await bcrypt.compare(password, user.password);
    if (!isMatch) return res.status(400).json({ message: 'Invalid credentials' });

    const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, { expiresIn: '1h' });
    res.json({ token });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

module.exports = router;

Step 5: Protecting Routes

Create a middleware for authentication:

const jwt = require('jsonwebtoken');

const authMiddleware = (req, res, next) => {
  const token = req.header('Authorization');
  if (!token) return res.status(401).json({ message: 'Access denied' });

  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (error) {
    res.status(400).json({ message: 'Invalid token' });
  }
};

module.exports = authMiddleware;

Step 6: Testing the API

Use Postman or any API testing tool to test:

📝 Register a user: POST /api/auth/register
🔑 Login a user: POST /api/auth/login
🔒 Access protected routes with the received token

Conclusion

✅ You've successfully built a secure authentication system in Node.js using JWT. This setup ensures users can securely authenticate and access protected resources.

Role-Based Authentication in MERN Stack: A Complete Guide

Manas Uniyal — Fri, 10 Jan 2025 12:34:00 +0000

Authentication is a crucial aspect of web applications, ensuring that only authorized users can access certain resources. Role-Based Authentication (RBAC) takes this a step further by assigning different permissions to users based on their roles.

In this post, we'll cover:
✅ What is Role-Based Authentication?
✅ Why Use Role-Based Authentication?
✅ How to Implement RBAC in a MERN Stack Application

What is Role-Based Authentication?
Role-Based Access Control (RBAC) is a security approach where users are assigned roles, and each role has specific permissions.

For example, in an e-commerce application:

Admin can add, edit, or delete products.
Seller can manage their own products.
Customer can only view and purchase products.
This ensures that users can only perform actions relevant to their roles.

Why Use Role-Based Authentication?
✔ Enhanced Security – Prevents unauthorized access to sensitive operations.
✔ Scalability – Easily add new roles and permissions as the system grows.
✔ Better User Management – Assign permissions without modifying code.

How to Implement RBAC in a MERN Stack Application?
1️⃣ Setting Up the User Model (MongoDB + Mongoose)
In your models/user.model.js:

javascript
Copy code
const mongoose = require("mongoose");

const UserSchema = new mongoose.Schema({
username: { type: String, required: true, unique: true },
email: { type: String, required: true, unique: true },
password: { type: String, required: true },
role: {
type: String,
enum: ["admin", "seller", "customer"],
default: "customer"
}
});

module.exports = mongoose.model("User", UserSchema);
🔹 Here, each user has a role field, which determines their permissions.

2️⃣ Generating JWT Tokens for Authentication
In your controllers/auth.controller.js:

javascript
Copy code
const jwt = require("jsonwebtoken");
const User = require("../models/user.model");

const login = async (req, res) => {
const { email, password } = req.body;
const user = await User.findOne({ email });

if (!user || user.password !== password) {
return res.status(401).json({ message: "Invalid credentials" });
}

const token = jwt.sign({ userId: user._id, role: user.role }, "SECRET_KEY", { expiresIn: "1h" });

res.json({ token, role: user.role });
};

module.exports = { login };
🔹 This function generates a JWT token containing the user's role.

3️⃣ Creating Middleware to Restrict Access
In middlewares/auth.middleware.js:

javascript
Copy code
const jwt = require("jsonwebtoken");

const authenticate = (req, res, next) => {
const token = req.header("Authorization")?.split(" ")[1];

if (!token) return res.status(403).json({ message: "Access denied" });

try {
const decoded = jwt.verify(token, "SECRET_KEY");
req.user = decoded;
next();
} catch (err) {
res.status(401).json({ message: "Invalid token" });
}
};

const authorize = (roles) => {
return (req, res, next) => {
if (!roles.includes(req.user.role)) {
return res.status(403).json({ message: "Forbidden" });
}
next();
};
};

module.exports = { authenticate, authorize };
🔹 authenticate – Ensures only logged-in users can access routes.
🔹 authorize – Restricts access based on roles.

4️⃣ Protecting Routes Based on User Roles
In routes/admin.routes.js:

javascript
Copy code
const express = require("express");
const { authenticate, authorize } = require("../middlewares/auth.middleware");

const router = express.Router();

router.get("/admin-dashboard", authenticate, authorize(["admin"]), (req, res) => {
res.json({ message: "Welcome to the Admin Dashboard" });
});

module.exports = router;
🔹 Only users with the admin role can access /admin-dashboard.

5️⃣ Implementing Role-Based UI in React
In App.js (Frontend):

javascript
Copy code
import { useState, useEffect } from "react";
import axios from "axios";

const App = () => {
const [role, setRole] = useState(null);

useEffect(() => {
const token = localStorage.getItem("token");
if (token) {
const decoded = JSON.parse(atob(token.split(".")[1]));
setRole(decoded.role);
}
}, []);

return (

Welcome to MERN Role-Based Authentication

{role === "admin" && Admin Dashboard}
{role === "seller" && Seller Dashboard}
{role === "customer" && Customer Dashboard}

);
};

export default App;
🔹 The UI displays different dashboards based on the user's role.

Conclusion
Role-Based Authentication is an essential security measure in modern web applications. By implementing RBAC in MERN Stack, you can control user permissions efficiently.

💡 Next Steps:
🔹 Add a role management panel for admins.
🔹 Implement database encryption for passwords.
🔹 Use Refresh Tokens for better security.

Want to learn more? Drop your questions in the comments! 🚀