AI Hype vs Actual Use: Is the AI Bubble Still On?

AI is everywhere.

Every product is “AI-powered.”
Every roadmap has AI.
Every demo looks impressive.

But if you are building real systems, you already know:

AI in production is very different from AI in presentations.

The Hype

The story sounds simple:

• Add AI
• Get intelligence
• Scale instantly

Clean input. Smart output. Done.

The Reality

Nothing is clean.

• Data is messy.
• Sensors drift.
• APIs are inconsistent.
• Latency exists.

Before AI even starts, you are already fixing problems.

Most of the work is not AI. It is data and systems.

What Breaks First

Data

You do not get a dataset.
You build one. Slowly.

Models

They do not crash.
They quietly become less useful.

Real-time

Looks great in slides.
Feels slow in production.

Expectations

This is where things get interesting.

The Expectation Gap (After AI Tools Arrived)

Then came AI tools and AI IDEs.

Suddenly everything looked faster:

• Code generation in seconds
• Models built in minutes
• Demos ready almost instantly

From the outside, it feels like:

“Now everything should be faster.”

What Leadership Often Assumes

At a high level, it sounds logical:

• AI writes code
• AI builds models
• AI speeds up development

So naturally:

• Timelines should shrink
• Teams should do more with less
• Complexity should reduce

What Actually Happens on the Ground

AI helps. No doubt.

But it does not remove the hard parts:

• Understanding messy requirements
• Handling real-world data issues
• Debugging edge cases
• Integrating with existing systems
• Making things reliable

AI accelerates output, but it does not remove complexity.

The Silent Pressure

This creates an unspoken expectation:

• “Why is this taking so long?”
• “Can’t AI handle this?”
• “This should be quicker now, right?”

Teams end up:

• Prototyping faster
• Struggling the same in production

The Reality Check

AI IDEs can generate code.

They cannot:

• Guarantee correctness
• Fully understand business context
• Handle production edge cases

The last 20% still takes the most effort.

And that part decides success or failure.

Hard Truth

Most problems do not need AI.

A simple rule often works:

• Faster
• Cheaper
• Easier to maintain

Adding AI too early just adds complexity.

So… Is It a Bubble?

Partly.

There is hype:

• Overuse of “AI-powered”
• Solving simple problems with complex tools
• Chasing trends

That will settle.

What Is Actually Real

AI works when:

• Patterns are complex
• Data is large
• Rules stop working

That is where it shines.

Not everywhere.

What Actually Works

Start simple

Rules first.
AI later.

Combine approaches

Rules + statistics + AI
This works in real systems.

Keep it replaceable

Models will change.
Your system should not break.

Monitor everything

If you cannot see it, you cannot trust it.

The Cost Nobody Talks About

AI is not just a model.

It is:

• Data pipelines
• Infrastructure
• Monitoring
• Retraining

AI is a system commitment.

Better Question to Ask

Not:

“Where can we use AI?”

But:

“Where are we stuck without it?”

Finally to conclude 

AI is real.
The hype is real too.

Both are happening at the same time.

The winners will not be the ones who use AI everywhere.
They will be the ones who use it where it actually matters.

If You Are Building

Focus on:

• Clean data
• Reliable systems
• Clear problems

Then bring in AI.

Bibliography

• Artificial Intelligence: A Modern Approach
• Stuart Russell, & Peter Norvig. Artificial intelligence: A modern approach (4th ed.). Pearson.
• Designing Data-Intensive Applications
• Martin Kleppmann. Designing data-intensive applications. O’Reilly Media.
• McKinsey & Company. The state of AI: Global survey. Retrieved from https://www.mckinsey.com/
• IBM: What is artificial intelligence? Retrieved from https://www.ibm.com/topics/artificial-intelligence
• Stanford University. AI Index Report. Retrieved from https://aiindex.stanford.edu/

Read More

Designing Scalable AIoT Systems: From Sensors to Cloud Intelligence

If you’ve ever worked on an AIoT system beyond a demo, you already know this truth:

Software proves its value not in code, but in the real world.

And AIoT is where that gap becomes crystal clear.

Sensors drift. Networks fluctuate. Devices behave unpredictably. APIs timeout. And your “perfect architecture diagram” starts evolving the moment it meets production.

This is not a theoretical guide. This is how scalable AIoT systems actually get built layer by layer, adapting to real-world complexity.

1. It Starts with the Sensor (and the Reality Check)

On paper, a sensor gives you clean data.

In reality:

• GPS jumps randomly between 10–100 meters
• Temperature sensors drift over time
• Vehicle signals come in bursts, not streams
• Some devices go silent for hours

If your system assumes perfect data, it will fail early.

What actually works:

• Always apply filtering (Kalman, smoothing, thresholding)
• Treat missing data as a first-class scenario
• Design for eventual consistency, not real-time perfection

Real-world example:
In vehicle systems, fuel level APIs often fluctuate ±3%. If you trigger alerts directly, users get spammed. You need stabilization logic.

2. Edge Layer: Where Intelligence Begins (Not Cloud)

A common mistake is pushing everything to the cloud.

That doesn’t scale.

Why?

• Latency matters (especially in automotive, industrial IoT)
• Connectivity is unreliable
• Cloud costs explode with raw data streaming

Edge computing is not optional.

Typical responsibilities at the edge:

• Data filtering & aggregation
• Local decision making (e.g., alerts, triggers)
• Compression before sending upstream
• Basic ML inference (TinyML, ONNX, TensorFlow Lite)

Rule of thumb:

If a decision needs to happen in <1 second, it should happen on the edge.

3. Communication Layer: The Most Underestimated Bottleneck

Most AIoT failures happen here, not in AI.

You’ll deal with:

• Intermittent connectivity
• Network switching (WiFi ↔ LTE ↔ offline)
• High latency in rural areas
• Message duplication

Protocols that actually work in production:

• MQTT → lightweight, reliable for IoT
• HTTP → good for batch and fallback
• WebSockets → for real-time dashboards

Design pattern:

• Use store-and-forward buffering
• Make APIs idempotent
• Expect retries → design for them

4. Backend Architecture: Where Scale Breaks or Holds

Once data hits your backend, things get interesting.

At small scale:

• A single FastAPI or Node service works fine

At scale:

• You need event-driven systems

Typical scalable architecture:

• Ingestion → API Gateway / MQTT Broker
• Stream → Kafka / Kinesis
• Processing → Microservices / Workers
• Storage → Time-series DB + NoSQL
• Serving → APIs + dashboards

Hard-earned lesson:

Don’t process everything synchronously.

Use async pipelines. Otherwise, one slow dependency will cascade failures.

5. Data Storage: Not Just “Save Everything”

AIoT generates massive data.

But storing everything is:

• Expensive
• Useless

Smart strategy:

• Raw data → short retention
• Aggregated data → long retention
• Critical events → permanent

Typical stack:

• Time-series DB (InfluxDB, TimescaleDB)
• NoSQL (DynamoDB, MongoDB)
• Object storage (S3)

6. AI Layer: Where Most People Overcomplicate

Let’s be honest; AI is often overused in AIoT.

You don’t always need deep learning.

What actually works in production:

• Rule-based systems (very underrated)
• Statistical models
• Lightweight ML

Use AI when:

• Patterns are complex
• Rules fail
• You have enough clean data

Example:
Predicting vehicle breakdown:

• Start with thresholds
• Move to regression
• Then ML if needed

7. Observability: Your Lifeline in Production

If you can’t see what’s happening, you can’t fix it.

You need:

• Logs (device + backend)
• Metrics (latency, failures, throughput)
• Traces (request flow)

Critical insight:
In AIoT, debugging often means answering:

“What exactly happened on that device 3 hours ago?”

If you don’t have that visibility, you’re blind.

8. Cost vs Scale: The Hidden Trade-off

Scaling AIoT is not just technical—it’s financial.

Costs come from:

• Cloud ingestion
• Storage
• Compute
• API calls (e.g., maps, location services)

Optimization strategies:

• Reduce data frequency
• Batch requests
• Move logic to edge
• Cache aggressively

9. Security: Often Ignored Until It’s Too Late

AIoT systems are vulnerable because they are distributed.

You must secure:

• Device identity
• Communication (TLS, certificates)
• API access
• Firmware updates

Golden rule:

If your device can connect, it can be attacked.

10. The Real Architecture (Not the Clean Diagram)

A real AIoT system looks like this:

• Messy inputs
• Partial failures
• Delayed data
• Retry storms
• Edge-case handling everywhere

And yet it works.

Because it’s designed for reality, not perfection.

Finally to conclude 

Designing scalable AIoT systems is not about picking the best tech stack.

It’s about understanding this:

The real world is noisy, unreliable, and unpredictable.

Your system should be too, but in a controlled way.

If you design for:

• failure
• latency
• inconsistency
• scale

Then your system won’t just work in demos, it will survive in production.

If You’re Building AIoT Today

Focus on this order:

• Data reliability
• Edge processing
• Communication resilience
• Backend scalability
• Observability
• AI (last, not first)

Bibliography

• Designing Data-Intensive Applications
• Martin Kleppmann. (2017). Designing data-intensive applications. O’Reilly Media.
• Amazon Web Services. (2023). AWS IoT Core developer guide. Retrieved from https://docs.aws.amazon.com/iot/
• Microsoft. (2023). Azure IoT reference architecture. Retrieved from https://learn.microsoft.com/en-us/azure/iot/
• Google Cloud. (2023). IoT architecture and solutions. Retrieved from https://cloud.google.com/solutions/iot
• Building the Internet of Things
• Maciej Kranz. (2016). Building the internet of things: Implement new business models, disrupt competitors, transform your industry. Wiley.
• IBM. (2022). What is edge computing? Retrieved from https://www.ibm.com/topics/edge-computing
• Cisco. (2021). Fog computing and the Internet of Things. Retrieved from https://www.cisco.com/

Read More

Building Smarter Robots with Small Language Models in Everyday Life

 🎉 Happy New Year to All My Readers 🎉

I hope this year brings health, learning, growth, and meaningful success to you and your loved ones.

A new year always feels like a clean slate. For technology, it is also a good moment to pause and ask a simple question:

Are we building things that are truly useful in daily life?

This is why I want to start the year by talking about something very practical and underrated
Small Language Models (SLMs) and how they can be used in robotics for everyday use cases in a cost-effective way.

Why We Are Considering Small Language Models (SLMs)

In real-world robotics, the goal is not to build the smartest machine in the world. The goal is to build a machine that works reliably, affordably, and efficiently in everyday environments. This is one of the main reasons we are increasingly considering Small Language Models instead of very large, general-purpose AI models.

Most robotic tasks are well-defined. A robot may need to understand a limited set of voice commands, respond to simple questions, or make basic decisions based on context. Using a massive AI model for such tasks often adds unnecessary complexity, higher costs, and increased latency. Small Language Models are focused by design, which makes them a much better fit for these scenarios.

Another important reason is cost efficiency. Robotics systems already require investment in hardware, sensors, motors, and power management. Adding large AI models on top of this quickly becomes expensive, especially when cloud infrastructure is involved. SLMs can run on edge devices with modest hardware, reducing cloud dependency and making large-scale deployment financially practical.

Reliability and control also play a major role. Smaller models are easier to test, debug, and validate. When a robot behaves unexpectedly, understanding the cause is far simpler when each model has a clearly defined responsibility. This modular approach improves safety and makes systems easier to maintain over time.

Privacy is another strong factor. Many robotics applications operate in homes, hospitals, offices, and factories. Running SLMs locally allows sensitive data such as voice commands or environment context to stay on the device instead of being sent to external servers. This builds trust and aligns better with real-world usage expectations.

Finally, SLMs support a long-term, scalable architecture. Just like microservices in software, individual AI components can be upgraded or replaced without rewriting the entire system. This flexibility is essential as AI technology continues to evolve. It allows teams to innovate steadily rather than rebuilding from scratch every few years.

For robotics in everyday life, intelligence does not need to be massive. It needs to be purpose-driven, efficient, and dependable. Small Language Models offer exactly that balance, which is why they are becoming a key building block in modern robotic systems.

From Big AI Models to Small Useful Intelligence

Most people hear about AI through very large models running in the cloud. They are powerful, but they are also expensive, heavy, and sometimes unnecessary for simple real-world tasks.

In daily robotics use, we usually do not need a model that knows everything in the world.
We need a model that can do one job well.

This is where Small Language Models come in.

SLMs are:

• Smaller in size
• Faster to run
• Cheaper to deploy
• Easier to control

And most importantly, they are practical.

Thinking of SLMs Like Microservices for AI

An Example architecture of Monolithic vs Microservices used in Software Inductries

In software, we moved from monolithic applications to microservices because:

• They were easier to maintain
• Easier to scale
• Easier to replace

The same idea works beautifully for AI in robotics.

Instead of one huge AI brain, imagine multiple small AI blocks:

• One model for voice commands
• One model for intent detection
• One model for navigation decisions
• One model for basic conversation

Each SLM does one specific task, just like a microservice.

This makes robotic systems:

• More reliable
• Easier to debug
• More cost-effective
• Easier to upgrade over time

Everyday Robotics Where SLMs Make Sense

Let us talk about real, everyday examples.

Home Robots

A home assistant robot does not need a giant model.
It needs to:

• Understand simple voice commands
• Respond politely
• Control devices
• Follow routines

An SLM running locally can do this without sending data to the cloud, improving privacy and reducing cost.

Office and Workplace Robots

In offices, robots can:

• Guide visitors
• Answer FAQs
• Deliver items
• Monitor basic conditions

Here, SLMs can handle:

• Limited vocabulary
• Context-based responses
• Task-oriented conversations

No heavy infrastructure needed.

Industrial and Warehouse Robots

Industrial robots already know how to move.
What they lack is contextual intelligence.

SLMs can help robots:

• Understand instructions from operators
• Report issues in natural language
• Decide next actions based on simple rules plus learning

This improves efficiency without increasing system complexity.

Healthcare and Assistance Robots

In hospitals or elderly care:

• Robots need predictable behavior
• Fast response
• Offline reliability

SLMs can be trained only on medical workflows or assistance tasks, making them safer and more reliable than general-purpose AI.

Why SLMs Are Cost-Effective

This approach reduces cost in multiple ways:

• Smaller models mean lower hardware requirements
• Edge deployment reduces cloud usage
• Focused training reduces development time
• Modular design avoids full system rewrites

For startups, researchers, and even individual developers, this makes robotics accessible, not intimidating.

The Bigger Picture

The future of robotics is not about giving robots human-level intelligence. It is about giving them just enough intelligence to help humans better.

SLMs enable exactly that.

They allow us to build robots that:

• Are useful
• Are affordable
• Are trustworthy
• Work in real environments

A New Year Thought

As we step into this new year, let us focus less on building the biggest AI and more on building the right AI.

• Small models.
• Clear purpose.
• Real impact.

Happy New Year once again to all my readers 🌟

Let us focus on building technology that serves people locally and globally, addresses real-world problems, and creates a positive impact on society.

Bibliography

• OpenAI – Advances in Language Models and Practical AI Applications
• Used as a reference for understanding how modern language models are designed and applied in real-world systems.
• Google AI Blog – On-Device and Edge AI for Intelligent Systems
• Referenced for insights into running AI models efficiently on edge devices and embedded systems.
• Hugging Face Documentation – Small and Efficient Language Models
• Used to understand lightweight language models, fine-tuning techniques, and deployment strategies.
• NVIDIA Developer Blog – AI for Robotics and Autonomous Systems
• Referenced for practical use cases of AI in robotics, including perception, navigation, and decision-making.
• MIT Technology Review – The Rise of Practical AI in Robotics
• Used for broader industry perspectives on how AI is shifting from experimental to everyday applications.
• Robotics and Automation Magazine (IEEE) – Trends in Modern Robotics Systems
• Referenced for understanding modular robotics architectures and intelligent control systems.
• Personal Industry Experience and Hands-on Projects
• Insights based on real-world development, experimentation, and system design experience in AI-driven applications.

Read More

The Year Technology Felt More Human : Looking Back at 2025

As this year comes to an end, there is a quiet feeling in the air.
Not excitement. Not hype.
Just reflection.

On start of 2025 felt like a year of dramatic announcements, AI bubbles or shocking inventions. Later, it felt like a year where technology finally settled down and started doing its job properly.

Shifted From More Noise to Less noise.
More Tech Gussips to More usefulness.

When Bigger Stopped Meaning Better

For a long time, the tech world believed that bigger was always better.
Bigger models. Bigger systems. Bigger promises.

But somewhere along the way in 2025, many of us realized something simple.
Most real-world problems do not need massive intelligence.
They need focused intelligence.

This is the year when smaller, purpose-built AI quietly proved its value.
Not by impressing us, but by working reliably in the background.

Technology Moved Closer to Real Life

Another thing that stood out this year was where technology lives.

AI slowly moved away from distant servers and closer to people:

• Inside devices
• Inside machines
• Inside everyday tools

This made technology feel less abstract and more personal.
Faster responses. Better privacy. Less dependency.

It started to feel like technology was finally meeting people where they are.

Robots Became Less Impressive and More Helpful

In earlier years, robots were exciting because they looked futuristic.
In 2025, robots mattered because they were useful.

Helping in hospitals.
Supporting workers.
Assisting at home.

They were not trying to be human.
They were simply trying to be helpful.

And that made all the difference.

Builders Changed Their Mindset

Something else changed quietly this year
The mindset of people building technology.

There was more talk about:

• Responsibility
• Simplicity
• Long-term impact

Less about chasing trends.
More about solving actual problems.

Developers stopped asking
“What is the latest technology?”

And started asking
“What is the right solution?”

Sustainability Finally Felt Real

2025 was also the year sustainability stopped being just a slide in presentations.

Efficiency mattered.
Energy use mattered.
Running smarter mattered more than running bigger.

Technology began respecting limits and that felt like progress.

What This Year Taught Me

If there is one thing 2025 taught us, it is this
Technology does not need to be loud to be powerful.

The best inventions of this year did not demand attention.
They earned trust.

They worked quietly.
They reduced friction.
They helped people live and work a little better.

A Simple Thought Before the Year Ends

As we step into a new year, I hope we carry this mindset forward.

Let us build technology that truly serves people locally and globally,
solves real-world problems,
and positively impacts everyday life.

No noise.
No unnecessary complexity.
Just thoughtful building.

Happy New Year in Advance to everyone reading this 🌟

Let us keep creating things that matter.

Image Links Reference used in this blog topic

• https://unsplash.com/s/photos/artificial-intelligence
• https://unsplash.com/s/photos/iot

Read More

The Future of Design Thinking in the Age of AI

Design Thinking has long been one of the most powerful human-centered methodologies for innovation. It’s a cyclical process of empathizing with users, defining their problems, ideating solutions, prototyping, and testing. What makes it unique is its focus on people first technology and business follow after.

But in the age of generative AI, this process is being fundamentally reimagined. AI is not here to replace designers or innovators, it’s a new creative collaborator that amplifies what humans already do best: empathy, problem-solving, and imagination.

Prototyping: From Manual Work to Instant Iteration

The prototyping phase: the “make it real” step is where AI is making some of the most visible impact. Traditionally, creating a high-fidelity prototype could take days or even weeks of wireframing, pixel pushing, and manual refinement. Today, with the right prompts, a designer can generate dozens of variations in minutes.

Case Study: Automating UI/UX Design

Tools like Uizard and Relume AI allow designers to upload a rough sketch or write a simple text prompt like:
“Design a mobile app interface for a fitness tracker with a clean, minimalist aesthetic.”

In seconds, the AI generates fully fleshed-out interfaces complete with layouts, color schemes, and even sample content. Designers can then test multiple versions with users, collect feedback quickly, and refine the best direction.

The result? The design-to-testing loop shortens dramatically. Designers spend less time perfecting the how and more time focusing on the why: understanding the user and creating meaningful experiences.

Ideation: Beyond the Human Brainstorm

Ideation or the brainstorming phase has always thrived on volume. The more ideas you generate, the greater the chances of finding a breakthrough. But human teams often plateau after a few dozen concepts. Generative AI, however, can serve as an idea engine that never runs out of fuel.

Example: A “How Might We…” Framework on Steroids

Take the challenge: “How might we make grocery shopping more sustainable?”

A traditional brainstorm might yield a dozen ideas, some practical and others far-fetched. With AI, a team can feed in user insights, market research, and competitive data. In return, the AI produces hundreds of potential solutions ranging from AI-driven meal planners that reduce food waste to smart carts that calculate carbon footprints in real time.

This flood of ideas isn’t meant to replace human creativity but to expand it. Designers shift roles from being sole inventors to curators and strategists, filtering and refining the most promising directions while bringing in human empathy and context.

Testing: Predictive and Proactive Feedback

Testing with real users remains a cornerstone of Design Thinking. But AI can make the process faster, broader, and more predictive.

Case Study: L’Oréal’s Predictive Product Testing

L’Oréal used generative AI to create virtual beauty assistants and marketing content at scale. By analyzing how users interacted with these digital experiences, they collected real-time insights long before manufacturing a single product. This helped them identify trends early and accelerate time-to-market by nearly 60%.

AI also enables virtual testing environments, simulating how users might interact with a product and spotting usability issues ahead of time. Instead of waiting for problems to emerge in expensive real-world tests, AI offers predictive feedback that helps refine designs earlier in the process.

The Evolving Role of Empathy

One area AI cannot replace is empathy. It can simulate patterns of user behavior, but it cannot truly understand human emotion, context, or cultural nuance. The future of Design Thinking in the age of AI will rely on humans doubling down on empathy and ethics, while AI handles scale, speed, and iteration.

This balance is critical. Without it, we risk building efficient but soulless products. With it, we create experiences that are not only faster to design but also deeper in impact.

Beyond Tools: New Challenges and Responsibilities

While AI supercharges Design Thinking, it also introduces new challenges:

• Bias in AI Models: If the data is biased, the design suggestions will be biased too. Human oversight is essential.

• Ethical Design: Who takes responsibility if an AI-generated idea leads to harm? Designers must act as ethical curators.

• Skill Shifts: Tomorrow’s designer will need to be part strategist, part prompt engineer, and part ethicist.

From Designers to Co-Creators

The future of Design Thinking isn’t about automating creativity but it’s about augmenting it. AI will take over repetitive tasks like rapid prototyping, data synthesis, and endless brainstorming. Designers, in turn, will have more space to do what only humans can: empathize, imagine, and shape products around real human needs.

The designer of tomorrow won’t just be a creator but they will be a co-creator alongside AI. They will guide machines with empathy, filter outputs with ethics, and ensure that innovation is not just faster, but also fairer and more human. 

Bibliography

• Brown, Tim. Change by Design: How Design Thinking Creates New Alternatives for Business and Society. Harper Business, 2009.
• IDEO. Design Thinking Process Overview. Retrieved from https://designthinking.ideo.com/
• Uizard. AI-Powered UI Design Platform. Retrieved from https://uizard.io/
• Relume AI. Design Faster with AI-Powered Components. Retrieved from https://relume.io/
• L’Oréal Group. AI and Beauty Tech Innovation Reports. Retrieved from https://www.loreal.com/
• Norman, Don. The Design of Everyday Things. MIT Press, 2013.
• Nielsen Norman Group. The Future of UX and AI-Driven Design. Retrieved from https://www.nngroup.com/

Read More