DEV Community: Ria saraswat

How Netflix Doesn't Crash During Peak Hours (Cloud Concepts) ! 😱

Ria saraswat — Sun, 19 Jul 2026 07:29:48 +0000

Millions of people open Netflix at the same time—during weekends, evenings, or when a new season drops. Despite this massive traffic, users usually experience smooth streaming with minimal downtime.

The reason isn't one powerful server. It's a cloud architecture designed for scalability, redundancy, and intelligent traffic management.

Let's look at the key cloud concepts that make this possible.

The Challenge

Imagine a new series is released.

Within minutes:

Millions of users log in
Thousands start streaming simultaneously
Search requests increase
Recommendation engines become active
Video delivery traffic spikes

If all these requests reached a single server, it would fail almost instantly.

Cloud architecture prevents this.

1. Load Balancing

A load balancer acts as a traffic controller.

Instead of sending every request to one server, it distributes traffic across multiple servers.

Benefits

Prevents server overload
Improves response time
Increases availability
Handles traffic spikes efficiently

Without load balancing, one busy server could bring down the entire application.

2. Auto Scaling

Traffic isn't constant throughout the day.

Cloud platforms automatically adjust the number of running servers based on demand.

During Peak Hours

More servers are launched automatically
Incoming traffic is distributed across them

During Low Traffic

Extra servers are removed
Infrastructure costs decrease

This ensures applications remain responsive without running unnecessary resources.

3. Content Delivery Network (CDN)

Streaming every video from one central server would introduce delays, especially for users far from the data center.

A CDN stores copies of content in multiple geographic locations.

When a user presses Play, the content is served from the nearest available location.

Advantages

Faster streaming
Lower latency
Reduced load on the origin servers
Better experience for global users

4. Caching

Not every request needs to reach the database.

Frequently accessed data is temporarily stored in cache.

Examples include:

User profiles
Movie posters
Trending lists
Homepage recommendations

Benefits

Faster responses
Lower database load
Reduced server processing

Caching significantly improves performance during traffic spikes.

5. Distributed Infrastructure

Instead of depending on one data center, cloud applications run across multiple regions and availability zones.

If one location experiences an issue:

Traffic is redirected
Other regions continue serving users
Service remains available

This improves both reliability and fault tolerance.

6. Database Replication

Millions of users continuously:

Log in
Save watch history
Update profiles
Add shows to watchlists

Handling all these requests with a single database would create a bottleneck.

Cloud systems use multiple database replicas.

Benefits

Higher read performance
Better availability
Reduced database overload

7. Monitoring and Alerts

Cloud infrastructure is monitored continuously.

Engineers track metrics such as:

CPU utilization
Memory usage
Network traffic
Error rates
Response time
Failed requests

If abnormal behavior is detected, alerts are triggered so issues can be addressed quickly.

Monitoring helps identify problems before users notice them.

8. Fault Tolerance

Cloud systems assume that failures will happen.

Instead of trying to prevent every failure, they are designed to recover automatically.

Examples include:

Restarting unhealthy servers
Redirecting traffic
Replacing failed instances
Recovering from hardware failures

The goal is to keep the service running even when individual components fail.

9. Microservices

Rather than running everything as one large application, different features are separated into independent services.

Examples include:

Authentication
Search
Recommendations
User profiles
Video streaming
Payments

If one service experiences an issue, the rest of the platform can continue functioning.

This makes scaling and maintenance much easier.

Putting It All Together

A typical request follows this flow:

User
   │
   ▼
CDN
   │
   ▼
Load Balancer
   │
   ▼
Application Servers
   │
   ▼
Cache
   │
   ▼
Database
   │
   ▼
Response

Each layer handles a specific responsibility, allowing the system to remain fast and reliable even under heavy traffic.

Key Cloud Concepts Used

Load Balancing
Auto Scaling
CDN
Caching
Distributed Infrastructure
Database Replication
Monitoring
Fault Tolerance
Microservices

These concepts work together to improve scalability, performance, and reliability.

Lessons for Developers

Even small projects can benefit from cloud design principles.

Instead of focusing only on writing code, think about:

How will the application scale?
What happens if one server fails?
Can frequently used data be cached?
Can traffic be distributed across multiple servers?
How will performance be monitored?

Building with these questions in mind leads to more resilient applications.

Final Thoughts

Netflix's reliability isn't the result of a single technology—it's the outcome of combining multiple cloud concepts into a well-designed architecture. Load balancing distributes traffic, auto scaling adjusts resources, CDNs reduce latency, caching minimizes repeated work, and monitoring keeps the system healthy.

The biggest takeaway isn't to copy Netflix's infrastructure, but to adopt the same mindset: build applications that can scale, recover from failures, and deliver a consistent user experience as demand grows.

Cloud Optimization: Building Faster, Cheaper & More Scalable Applications! ✨

Ria saraswat — Sun, 19 Jul 2026 06:28:42 +0000

Cloud optimization is the process of improving cloud infrastructure to achieve better performance while reducing operational costs.

Instead of simply adding more resources, optimization focuses on using existing resources efficiently through monitoring, automation, and architectural improvements.

This document summarizes the key techniques and best practices I learned while studying cloud optimization.

Why Cloud Optimization Matters

Reduces unnecessary cloud spending
Improves application performance
Makes applications scalable
Prevents resource wastage
Improves system reliability
Helps maintain predictable infrastructure costs

Core Optimization Areas

1. Right-Sizing Resources

Choose instance sizes based on actual workload instead of assumptions.

Best Practices

Monitor CPU and memory utilization
Downsize underutilized servers
Upgrade only when consistently required
Remove unused storage volumes

Goal: Pay only for the resources your application actually needs.

2. Auto Scaling

Instead of keeping maximum resources running all the time, automatically increase or decrease resources based on traffic.

Scale Up

High CPU usage
Increased request count
Heavy user traffic

Scale Down

Low traffic
Idle resources
Off-peak hours

Benefits

Better availability
Lower infrastructure cost
Improved user experience

3. Load Balancing

A load balancer distributes incoming traffic across multiple servers.

Advantages

Prevents server overload
Improves response time
Increases fault tolerance
Supports horizontal scaling

Common strategies include:

Round Robin
Least Connections
Weighted Routing

4. Caching

Caching stores frequently accessed data closer to users or applications.

Common Cache Layers

Browser Cache
CDN Cache
Database Cache
Application Cache

Popular tools:

Redis
Memcached

Benefits

Faster responses
Lower database load
Reduced latency

5. Storage Optimization

Different data requires different storage solutions.

Frequently Accessed Data

SSD Storage
High-performance disks

Rarely Accessed Data

Cold storage
Archive storage

Best Practices

Delete unused files
Compress large files
Use lifecycle policies
Store backups separately

6. Database Optimization

Databases often become performance bottlenecks.

Optimization Techniques

Create indexes
Optimize queries
Remove duplicate data
Archive old records
Enable query caching

Monitor:

Query execution time
Database connections
Read/write latency

7. CDN (Content Delivery Network)

A CDN stores static content on servers located around the world.

Instead of serving files from one server, users receive content from the nearest location.

Content Suitable for CDN

Images
CSS
JavaScript
Videos
Fonts

Benefits include:

Lower latency
Faster page load
Reduced origin server traffic

8. Monitoring & Observability

Optimization starts with measurement.

Track metrics such as:

CPU utilization
Memory usage
Disk I/O
Network traffic
Response time
Error rate
Request count

Popular monitoring tools:

AWS CloudWatch
Grafana
Prometheus

9. Cost Optimization

Small changes can significantly reduce cloud expenses.

Practical Tips

Stop idle virtual machines
Delete unused storage
Remove orphaned snapshots
Use Reserved Instances for predictable workloads
Use Spot Instances for fault-tolerant jobs
Enable automatic resource shutdown

Always review billing reports regularly.

10. Serverless Computing

Instead of managing servers, execute functions only when needed.

Examples:

AWS Lambda
Azure Functions
Google Cloud Functions

Advantages:

No server management
Automatic scaling
Pay only for execution time

Ideal for:

APIs
Event-driven systems
Automation tasks

Security While Optimizing

Cost optimization should never compromise security.

Follow these practices:

Encrypt stored data
Use IAM roles with least privilege
Rotate secrets regularly
Enable logging and auditing
Keep services updated
Restrict public access

Optimization Workflow

Monitor infrastructure metrics.
Identify bottlenecks.
Analyze resource utilization.
Optimize compute, storage, and networking.
Automate scaling.
Review costs regularly.
Repeat continuously.

Cloud optimization is an ongoing process, not a one-time task.

Common Mistakes

Overprovisioning resources
Ignoring monitoring data
Running idle servers
Using expensive storage unnecessarily
Not enabling auto scaling
Missing cost alerts
Optimizing without benchmarking

Key Takeaways

Optimize based on real usage, not assumptions.
Monitor before making changes.
Automate scaling wherever possible.
Cache frequently accessed data.
Use the right storage tier.
Continuously review cloud costs.
Balance performance, scalability, and security.

Conclusion

Cloud optimization is about building efficient systems rather than simply increasing infrastructure. By combining monitoring, auto scaling, caching, efficient storage, database tuning, and cost management, applications become faster, more reliable, and significantly more cost-effective. Continuous optimization ensures that cloud resources are aligned with application demand while avoiding unnecessary expenses.

Japan has built AI system that can even beat Anthropic FABLE-5! 🤯

Ria saraswat — Mon, 06 Jul 2026 08:59:14 +0000

For the last few years, the AI race has looked predictable.

Train a bigger model.
Add more parameters.
Spend more GPUs.
Hope it beats everyone else.

Then a Japanese startup called Sakana AI asked a different question:

What if the future isn't one super-intelligent model? What if it's a system that knows how to coordinate many specialized models?

That question led to Sakana Fugu, one of the most interesting AI releases of 2026.

While headlines focused on "Japan built AI that beat Fable 5," the real innovation isn't about winning benchmarks. It's about changing how we build AI systems.

The Traditional LLM Architecture

Most frontier AI models follow the same philosophy.

User
  │
  ▼
Large Language Model
  │
  ▼
Response

Everything happens inside one enormous neural network.

Whether you're asking it to:

write code
debug software
summarize research
solve math
design a UI

...the same model handles every task.

This approach has worked incredibly well, but it also has limitations.

No single model is the best at everything.

Sakana's Different Idea

Instead of creating one gigantic expert, Fugu creates an intelligent coordinator.

Think of it as a technical lead rather than a software engineer.

When a request arrives, Fugu:

Understands the problem.
Breaks it into subtasks.
Chooses the most capable model for each subtask.
Collects every result.
Verifies consistency.
Produces one final answer.

From the user's perspective, it still looks like one AI.

Internally, however, multiple models may have collaborated on the solution.

An Example

Imagine asking:

"Build a full-stack expense tracker with authentication, database schema, Docker setup, tests, and deployment instructions."

A traditional model tries to solve everything itself.

Fugu can instead orchestrate specialists.

                User Prompt
                     │
                     ▼
             Fugu Orchestrator
                     │
 ┌──────────┬──────────┬──────────┬─────────┐
 ▼          ▼          ▼          ▼
Coding   Architecture Testing Documentation
Model      Model        Model        Model
 └──────────┴──────────┴──────────┴─────────┘
                     │
                     ▼
             Unified Final Response

This resembles how engineering teams already work.

Why This Is Interesting

Modern AI isn't suffering because models are "bad."

It's suffering because different models excel at different things.

For example:

one model writes exceptional code
another reasons better
another is faster
another has stronger multimodal capabilities

Instead of forcing one model to do everything, Fugu lets each contribute where it performs best.

"System as a Model"

Sakana describes Fugu as a System as a Model.

Instead of exposing users to:

routing
prompt engineering
agent frameworks
workflow graphs

everything is hidden behind a single API.

Developers simply call:

response = client.responses.create(...)

Behind that request, the orchestration engine decides how many agents to create, which models to use, and how to combine their outputs.

Did It Really Beat Fable 5?

This is where headlines became misleading.

Sakana reported that Fugu Ultra matched or exceeded Anthropic's Fable 5 on several engineering and scientific benchmarks, including LiveCodeBench and GPQA-Diamond.

That does not mean:

it is universally smarter
every response is better
it replaces every frontier model

Benchmarks measure specific capabilities under controlled conditions.

Real-world performance still depends on latency, cost, context length, reliability, and task complexity.

The Bigger Industry Shift

The most exciting part isn't the benchmark table.

It's the architectural philosophy.

For years the industry asked:

"Who has the biggest model?"

Now a new question is emerging:

"Who can coordinate intelligence the best?"

That is a fundamentally different problem.

Instead of scaling parameters, researchers are scaling collaboration.

What This Means for Developers

If orchestration systems become mainstream, developers may stop choosing a single AI model.

Instead, they'll choose an orchestration layer that automatically selects the right model for each task.

Future applications could look like this:

Your App
    │
    ▼
Orchestration Layer
    │
 ┌──┴───────────────┐
 │                  │
Coding Model    Vision Model
 │                  │
Reasoning Model Translation Model
 │                  │
 └──────Merge Results──────┘
            │
            ▼
      Final Response

Developers write against one API.

The orchestration engine handles the complexity.

Challenges

This approach isn't perfect.

Coordinating multiple models introduces new trade-offs:

higher latency
increased inference cost
more complex debugging
routing errors
response consistency

The orchestration layer itself becomes one of the hardest engineering problems in AI.

Final Thoughts

Sakana Fugu may or may not become the dominant AI platform.

But it has already changed the conversation.

Instead of asking:

"How do we build one model that knows everything?"

it asks:

"How do we build a system where many models become smarter together?"

That shift—from larger models to better orchestration—could define the next generation of AI systems.

Whether Fugu ultimately wins or not, its biggest contribution may be proving that the future of AI isn't just about smarter models—it's about smarter systems.

🚀 Building a 4-in-1 AI Summarizer: One Tool for Meetings, Articles & Code!

Ria saraswat — Sat, 04 Jul 2026 18:25:18 +0000

The Problem

In an era of endless meetings, long-form articles, and complex technical documentation, information overload is a real challenge. I found myself constantly switching between tools to understand content, which led me to a simple question:

What if I had one tool that could handle all of these different formats efficiently?

💡 The Solution: 4-in-1 AI Summarizer

I built a versatile, AI-powered tool designed to streamline information processing. By consolidating multiple needs into one interface, it helps users quickly extract the "need-to-know" information, whether it’s a transcript, a technical article, or a snippet of code.

✨ Key Features

Multi-Mode Processing: Built-in logic tailored for Meetings (action items), Articles (key concepts), and Code (technical explanations).
Clean Markdown Output: Summaries are structured using markdown to ensure they are readable and ready for documentation.
Polished UX: Integrated Tailwind's typography plugin to provide a distraction-free, professional reading experience.

🛠️ The Tech Stack

Framework: Built for speed and efficiency using modern web frameworks.
AI Engine: Powered by Groq and Google Gemini APIs to deliver fast, high-quality analysis.
Deployment: Navigated the complexities of production environments to make the tool live and accessible.

🚧 Challenges I Overcame

This project wasn't just about writing code; it was about learning how to manage a real-world application.

Environment Configuration: Solving the "it works on my machine" problem by managing environment variables effectively in a production environment.
API Reliability: Tackling authentication errors and model availability issues to ensure the summarizer is stable.
Workflow Discipline: Re-initializing my Git repository and fixing branch configurations taught me the importance of maintaining a clean version control history.

🔮 What's Next?

Building this project was a huge milestone in my journey. Moving forward, I plan to:

Optimize the processing speed for even longer documents.
Add a feature for exporting summaries directly to PDF or Notion.
Continue refining the UI for an even smoother user experience.

🙌 Thanks for Reading!

If you're building something similar or have feedback on my project, I'd love to connect!

🔗 Repository

https://github.com/Dare-TechieZ/4-in-1-summarizer-aws-project-week3

🌐 Live Demo

https://4-in-1-summarizer-aws-project-week3.vercel.app/

Made by Team Cipher during the AWS Summer Builder Cohort – Week 3.

Why Docker Containers Changed Software Deployment ? 🤔

Ria saraswat — Tue, 30 Jun 2026 15:21:03 +0000

Imagine building an application that works perfectly on your computer but crashes immediately when someone else tries to run it.

This classic problem led to one of the biggest innovations in modern software development: Docker.

Docker packages an application along with everything it needs to run, ensuring it behaves consistently across different environments.

Let's understand why Docker has become an essential tool for developers and DevOps engineers.

The Problem Before Docker

Developers often faced issues like:

Different operating systems
Missing software dependencies
Different library versions
Configuration mismatches

The infamous phrase:

"It works on my machine!"

became a common frustration.

Deployments were slow, inconsistent, and difficult to debug.

What is Docker?

Docker is a platform that allows developers to package applications into containers.

A container includes:

Application code
Runtime
Libraries
Dependencies
Configuration files

Because everything is packaged together, the application behaves the same wherever it runs.

Virtual Machines vs Containers

Virtual Machines

A Virtual Machine includes:

Entire operating system
Application
Dependencies

Advantages:

Strong isolation
Multiple operating systems on one host

Disadvantages:

Large storage requirements
Slower startup
Higher resource usage

Containers

Containers share the host operating system while keeping applications isolated.

Advantages:

Lightweight
Fast startup
Portable
Efficient resource usage

This makes containers ideal for cloud-native applications.

Docker Images

A Docker Image is a blueprint for creating containers.

It contains everything required to run an application:

Source code
Libraries
Runtime
Environment configuration

Think of an image as a recipe.

You can create multiple containers from the same image.

Docker Containers

A Docker Container is a running instance of a Docker image.

If the image is the recipe, the container is the prepared meal.

Containers can be:

Started
Stopped
Restarted
Deleted

without affecting the original image.

What is a Dockerfile?

A Dockerfile is a text file containing instructions for building an image.

A typical Dockerfile specifies:

Base image
Working directory
Dependencies
Source code
Startup command

Instead of manually setting up an environment every time, Docker builds everything automatically.

Docker Hub

Docker Hub is a cloud repository for Docker images.

Developers can:

Download official images
Share their own images
Reuse community-maintained images

Popular images include:

Python
Node.js
MySQL
PostgreSQL
Redis
Nginx

This saves time and simplifies application setup.

Typical Docker Workflow

A simple workflow looks like this:

Write your application.
Create a Dockerfile.
Build a Docker image.
Run a Docker container.
Test locally.
Push the image to Docker Hub.
Deploy it to a cloud platform such as AWS, Azure, or Google Cloud.

The same container can run consistently across development, testing, and production environments.

Benefits of Docker

Docker has transformed software deployment by offering:

Faster deployments
Consistent environments
Simplified dependency management
Better collaboration
Easy scalability
Efficient resource utilization
Cloud-ready applications

These advantages make Docker a cornerstone of modern DevOps practices.

Where Docker is Used

Docker is widely used in:

Web application deployment
Microservices architecture
Continuous Integration and Continuous Deployment (CI/CD)
Cloud-native development
Machine Learning model deployment
Testing environments
API development

Many companies rely on Docker to ensure their applications run reliably across different infrastructures.

Conclusion

Docker solved one of software development's most persistent problems: environment inconsistency.

By packaging applications and their dependencies into lightweight containers, Docker enables developers to build once and run anywhere.

Whether you're exploring DevOps, cloud computing, backend development, or preparing for technical interviews, learning Docker is a valuable investment. It lays the foundation for understanding modern deployment pipelines and scalable cloud applications.

Start with a simple application, containerize it, and experience how Docker makes deployments predictable and efficient.

Happy containerizing! 😊

Authentication vs Authorization in Cloud Security: Understanding the Difference 🔥

Ria saraswat — Sat, 27 Jun 2026 16:16:58 +0000

When we use applications like Gmail, Netflix, or online banking, we rarely think about the security processes happening in the background. Yet every login and every action we perform depends on two fundamental concepts: Authentication and Authorization.

Although these terms are often used interchangeably, they serve completely different purposes. Understanding their difference is essential for anyone learning cloud computing, cybersecurity, or software development.

What is Authentication?

Authentication is the process of verifying who you are.

Before granting access to any application, the system needs to confirm your identity. This is usually done through credentials such as:

Username and password
One-Time Password (OTP)
Fingerprint or Face ID
Security keys
Multi-Factor Authentication (MFA)

Think of authentication as showing your ID card before entering a secure building.

Example

When you log into Gmail:

You enter your email address.
You enter your password.
Google verifies your credentials.
If correct, you are successfully authenticated.

At this point, Google knows you are the legitimate owner of the account.

What is Authorization?

Authorization determines what you are allowed to do after you've been authenticated.

Just because a user can log in doesn't mean they should have access to every feature.

Authorization decides permissions such as:

Reading files
Editing documents
Deleting resources
Managing users
Accessing confidential information

Think of authorization as deciding which rooms you can enter after you've entered the building.

Real-World Examples

Netflix

Authentication:

Logging into your Netflix account using your email and password.

Authorization:

A Kids profile cannot access mature content.
Different subscription plans allow different streaming limits.

Gmail

Authentication:

Signing in with your Google account.

Authorization:

You can access your own emails.
You cannot access another user's mailbox.

Online Banking

Authentication:

Authorization:

View account balance.
Transfer money.
Download statements.
Access only accounts linked to you.

Authentication Methods

Password-Based Authentication

The most common method where users provide a username and password.

Pros:

Easy to implement
Familiar to users

Cons:

Weak passwords
Password reuse
Phishing attacks

Multi-Factor Authentication (MFA)

MFA requires users to verify their identity using multiple factors.

For example:

Password
OTP sent to phone
Fingerprint

Even if a password is stolen, attackers still need the second verification factor.

OAuth

OAuth allows users to log into one application using another trusted account.

Examples include:

Continue with Google
Sign in with GitHub
Continue with Microsoft

Instead of sharing your password with every website, OAuth securely delegates authentication.

Authorization Models

Role-Based Access Control (RBAC)

Permissions are assigned based on roles.

For example:

Admin

Create users
Delete resources
Manage settings

Developer

Deploy applications
View logs

Viewer

Read-only access

RBAC simplifies permission management in organizations.

IAM Policies

Cloud providers like AWS use Identity and Access Management (IAM) policies.

An IAM policy defines exactly what actions a user or service can perform.

Example:

Read files from storage
Start virtual machines
Access databases
Deny deletion of resources

Following the principle of least privilege ensures users receive only the permissions they truly need.

Common Mistakes

Many beginners make these security mistakes:

Assuming authentication automatically grants full access.
Giving administrator privileges to every user.
Not enabling Multi-Factor Authentication.
Sharing accounts among multiple users.
Using weak or reused passwords.

These mistakes increase the risk of unauthorized access and data breaches.

Best Practices

To build secure cloud applications:

Always enable Multi-Factor Authentication.
Follow the Principle of Least Privilege.
Use Role-Based Access Control.
Regularly review user permissions.
Rotate credentials periodically.
Monitor login activity.
Avoid hardcoding passwords or API keys.

Conclusion

Authentication answers the question:

"Who are you?"

Authorization answers:

"What are you allowed to do?"

Both are essential pillars of cloud security. Authentication protects identity, while authorization protects resources. Together, they help ensure that only the right users can access the right systems with the right permissions.

Whether you're building cloud applications, deploying services on AWS, or preparing for technical interviews, understanding these concepts is a strong foundation for secure software development.

Happy learning!

WHY MY FILES NEVER TOUCH MY SERVER ?? 🤔

Ria saraswat — Sat, 20 Jun 2026 17:36:00 +0000

When I first started building cloud projects, I assumed file uploads worked like this:

📂 User Uploads File
⬇️
🖥️ Server Stores File on Its Disk

Simple, right?

But while building RIA Vault, a cloud document management dashboard, I learned that modern cloud applications often work very differently.

Instead of storing files on the server itself, my architecture looks like this:

📂 User
⬇️
🌐 Frontend (Vercel)
⬇️
⚙️ Flask Backend (Render)
⬇️
☁️ AWS S3

So where does the file actually live?

👉 Not on my server.

👉 Not on Render.

👉 Inside Amazon S3.

What happens when a user uploads a file?

1️⃣ The user selects a file from the dashboard.

2️⃣ The frontend sends the file to my Flask backend using the Fetch API.

3️⃣ The backend receives the file and uses AWS Boto3 SDK.

4️⃣ Boto3 calls Amazon S3's upload service.

5️⃣ S3 stores the file and returns a success response.

6️⃣ The dashboard instantly updates to show the uploaded file.

Why not store files on the server?

Imagine 10,000 users uploading documents.

If everything is stored directly on the server:

❌ Storage fills up quickly
❌ Scaling becomes difficult
❌ Server crashes can affect files
❌ Managing backups becomes a headache

Using Amazon S3 solves many of these problems:

✅ Highly scalable storage
✅ Designed for massive amounts of data
✅ Better reliability and durability
✅ Pay only for what you use

AWS Services I Used

🔹 Amazon S3 – Cloud object storage

🔹 AWS Boto3 SDK – Python SDK to interact with AWS services

Key methods used:

s3_client.upload_fileobj()
s3_client.list_objects_v2()
s3_client.delete_object()

These three methods powered the core functionality of my project:

📤 Upload Files

📋 View Files

🗑️ Delete Files

My Biggest Learning

Before this project, I thought cloud storage was just "a folder on the internet."

After building with AWS S3, I realized modern applications separate:

🖥️ Compute Layer → Handles requests

☁️ Storage Layer → Stores files

This separation makes applications easier to scale, maintain, and deploy.

Building projects teaches concepts that documentation alone cannot.

What's one AWS service that completely changed how you think about cloud architecture?

Google is Secretly Trying to Run a 4GB AI Model Without You Knowing it! 😱

Ria saraswat — Fri, 19 Jun 2026 15:10:23 +0000

I recently discovered something interesting.

If you're using Google Chrome, there is a chance that Chrome has downloaded a 4GB AI model called Gemini Nano directly onto your computer without a clear notification. The file is usually stored as weights.bin inside Chrome's local data folders.

What is Gemini Nano?

Gemini Nano is Google's lightweight AI model designed to run directly on your device instead of sending everything to cloud servers. It powers features such as:

"Help Me Write" assistance
On-device scam detection
Text summarization
AI-powered browser features and APIs

The goal is faster responses and better privacy because some processing happens locally.

👍 Benefits

Better privacy (less data sent to the cloud)
Faster AI responses
Works even with limited internet connectivity
Powers s
ecurity features like scam detection locally

👎 Downsides
Consumes around 4GB of storage
Can increase RAM usage during AI tasks
May affect laptops with lower memory (8GB–12GB RAM)
Uses bandwidth for downloading the model
Many
users were unaware it had been downloaded

How to Check if You Have It (Windows)

Open File Explorer and check:

C:\Users\YOUR_USERNAME\AppData\Local\Google\Chrome\User Data\

Look for a folder named:

OptGuideOnDeviceModel

If you see a large weights.bin file (~4GB), that's Gemini Nano.

** How to Remove It Completely**

Step 1: Open Chrome

Go to:

chrome://settings/system

Disable:

On-device AI

Step 2: Open

chrome://flags

Search and disable:

Gemini Nano
Prompt API
Optimization Guide On Device Model
Other Gemini-related experimental flags

Step 3: Close Chrome completely.

Step 4: Delete the folder:

OptGuideOnDeviceModel

Step 5 (Optional):
Enterprise/advanced users can block future downloads through Chrome policies. Google has also added controls to disable and remove the model in newer Chrome versions.

My Take

Running AI locally is the future.

But if an AI model takes 4GB of storage and potentially several more GB of RAM while running, users should be informed before it lands on their devices.

Privacy-friendly AI is great.

Silent 4GB downloads? That's where the debate starts.

Hackathon Survival Guide: Questions Every Team Should Be Ready to Answer 🚀

Ria saraswat — Thu, 18 Jun 2026 12:22:28 +0000

As someone who has participated in multiple hackathons and won a national-level hackathon, I've noticed that many teams focus heavily on coding but underestimate the importance of project understanding, architecture design, and judge Q&A preparation.

Most hackathon teams spend 90% of their time building and only 10% preparing for judging.

That's backwards.

A great idea can lose because the team cannot explain:

Why the problem matters
How the solution works
Why AI is needed
How the system scales

Here are the most common hackathon questions and how to prepare for them.

1. What Problem Are You Solving?

Many teams immediately start explaining features.

Judges want:

What is the problem?
Who faces it?
How serious is it?

Example:

❌ "We built an AI return prediction system."

✅ "Small e-commerce sellers lose money because customers return products due to incorrect expectations, sizing confusion, and poor product understanding."

Start with pain, not features.

2. Why Is This Problem Important?

Be ready with:

Statistics
Market size
User stories
Financial impact

Judges love evidence.

3. Why AI?

One of the most common questions.

Many projects simply add ChatGPT because it's trendy.

Be ready to answer:

"Why can't this be solved with traditional software?"

Good examples:

✅ Recommendation systems
✅ Image understanding
✅ Natural language analysis
✅ Predictive modeling

Bad examples:

❌ AI calculator
❌ AI login page
❌ AI to display static information

4. How Does Your System Work?

Prepare a simple architecture diagram.

Typical flow:

User
 ↓
Frontend
 ↓
Backend API
 ↓
AI Model
 ↓
Database
 ↓
Response

Avoid overly complex diagrams.

If you cannot explain your architecture in 60 seconds, simplify it.

5. What Makes Your Solution Different?

Judges often ask:

"What already exists?"

Before the hackathon:

Search competitors
List alternatives
Explain your unique advantage

No solution is truly unique.

The difference is usually:

Better UX
Lower cost
Faster execution
Better accessibility

6. How Will You Scale?

Even if your project is a prototype.

Be ready to discuss:

More users
Larger datasets
Cloud deployment
Performance

Judges want to see long-term thinking.

7. How Accurate Is Your AI?

If using AI:

Expect questions about:

Accuracy
Hallucinations
False positives
Failure cases

Never claim 100% accuracy.

Instead explain:

Limitations
Validation methods
Human review mechanisms

8. What Happens If AI Fails?

This is a surprisingly common question.

Good systems have fallback plans.

Example:

If the AI confidence score is low:

Ask for more information
Escalate to human review
Use a rule-based fallback

How Much AI Can You Use?

Short answer:

Use as much AI as the hackathon rules allow.

Modern hackathons generally care about:

Problem solving
Product thinking
Execution

Not whether every line of code was handwritten.

Using:

ChatGPT
Claude
Gemini
Cursor
GitHub Copilot
Windsurf

is usually acceptable.

However:

❌ Don't let AI build everything without understanding it.

If judges ask:

"How does this API work?"

and you answer:

"I don't know, AI wrote it."

You're in trouble.

Rule:

Use AI to build faster.
Understand everything you submit.

What Should You Prepare Before a Hackathon?

Technical:

GitHub repository
Deployment platform
API keys
Architecture diagram
Backup plan

Presentation:

30-second pitch
2-minute pitch
5-minute demo

Documentation:

Problem statement
User persona
Architecture
Future scope

The Winning Formula

Strong teams don't just build.

They can clearly answer:

What problem exists?
Why does it matter?
Why is AI needed?
How does the system work?
What makes it different?
How will it scale?
What are its limitations?

The best hackathon projects are not always the most complex.

They're the ones that solve a real problem and communicate it clearly.

If you found this helpful, consider sharing it with your hackathon team or fellow builders. 🚀

I'd also love to hear:

💡 What's the most challenging question a judge has asked about your project?

Let's help each other become better builders, not just better coders.

Happy hacking! 🎯

Top 10 Prompt Engineering Concepts Every AI Developer Should Master in 2026 !🚀

Ria saraswat — Thu, 18 Jun 2026 12:12:12 +0000

After completing a Prompt Engineering learning path on CodeSignal, I realized that effective prompting is much more than asking better questions. It's about designing inputs that help LLMs produce reliable, structured, and useful outputs.

Here are some of the most important concepts every AI developer should know:

🔥 Task Analysis & Outcome Definition
Clearly define what the model should accomplish before writing a prompt.

🔥 Context Engineering
Provide the right background information so the model has the necessary knowledge to respond accurately.

🔥 Constraint-Based Prompting
Specify requirements such as format, length, tone, exclusions, and rules.

🔥 Few-Shot Prompting
Guide the model using examples of desired inputs and outputs.

🔥 Chain-of-Thought Reasoning
Break complex problems into smaller logical steps to improve reasoning quality.

🔥 Format Control
Generate structured outputs using JSON, Markdown, tables, or predefined schemas.

🔥 Text Transformation
Summarize, rewrite, expand, translate, or modify content while preserving key information.

🔥 Iterative Prompting
Refine prompts based on model responses to improve output quality.

🔥 Prompt Testing & Evaluation
Test prompts across different inputs to ensure consistency and reliability.

Looking ahead, AI developers should also explore:
🔹 Retrieval-Augmented Generation (RAG)
🔹 AI Agents
🔹 Function Calling
🔹 Prompt Security
🔹 LLM Evaluation Frameworks

If you want to take codesignal course visit:

Make ChatGPT, Claude, and other GenAIs work for you with this beginner-friendly introduction to Prompt Engineering. Learn how Large Language Models (LLMs) work and how to influence them with precise prompts to generate the outputs you need.

codesignal.com

If you want to verify my skills,visit:

codesignal.com

Prompt engineering is evolving from a writing skill into a core software engineering discipline for building reliable AI applications.

What prompt engineering techniques have you found most useful in real-world projects?