Forem: Saad Naeem

Something Changed in AI, And It’s Not the Models

Saad Naeem — Mon, 12 Jan 2026 19:39:46 +0000

Artificial Intelligence Isn't a Feature – It's Becoming Infrastructure

As developers, we have noticed how AI has become very active recently.

Initially, it was quite thrilling.
“And then came a point when it

Now, it’s beginning to feel. inevitable.

A common issue facing the team described in this case and those of others I interact with:

“We know AI can help, but we don’t know where it actually fits.”
AI, or Artificial Intelligence, refers to software

We could discuss that honestly.

The Real Pain Pain Clinics Are Facing

Most developers won’t have a problem creating things.

They have difficulty constructing the right thing.

Common issues I observe in teams:

"Q&A" chatbots | Can’t act | Cite example | Do

Automation scripts which fail the moment logic increases

Artificial intelligence capabilities were considered as functions, rather than as integrated systems. Additionally,

Ownership is still unclear when the “AI part goes live”

The consequence?

The AI is there in the product, but it doesn’t add much value to the business.

“Just Add AI” Usually Fails: Why It’s

AI is often added in that way:

“Let’s add a chatbot”

“Let's automate responses to support.”

“Let's use GPT here”

"This works for demos."
This works for demos.
It fails in production.

Why?

Because businesses don’t need AI responses
They need AI responsibility

Who handles the conversation?
Who decides the next step?
Who connects AI to CRM, calls, tickets, workflows?

That’s where most implementations stop.

The Shift: From AI Tools to AI Agents

What’s changing now is how AI is used.

Instead of:

One chatbot

One script

One endpoint

Teams are moving toward AI agents:

Agents that can chat, call, update systems

Agents that follow rules, not just prompts

Agents that act like digital team members

This is where AI starts becoming infrastructure, not a feature.

What Developers Should Focus On

If you’re building or planning AI features, ask these questions:

Can this AI take actions, or only respond?

Can it work 24/7 without supervision?

Is it connected to real systems (CRM, DB, APIs)?

Can the logic evolve without rewriting everything?

If the answer is “no” to most of these, the AI will likely stay a demo.

A Practical Observation

In several projects I’ve seen (especially MVPs and SaaS products), teams succeed when they:

Treat AI as a system, not a widget

Design flows before prompts

Think in terms of agents, not chat windows

Some companies working deeply in this space (for example, teams Stripe , vortician, Notion
) focus more on AI behavior and integration than on UI or hype — and that’s usually where long-term value comes from.

Not because of tools, but because of architecture decisions.

Final Thought

AI isn’t replacing developers.
But developers who understand where AI fits will replace those who don’t.

If you treat AI as:

a feature → it stays small

a system → it scales with your product

And that mindset shift is already happening.

Connect MongoDB database with Next JS App(the simplest way)

Saad Naeem — Wed, 03 Jul 2024 14:10:24 +0000

In Next.js, especially when deploying on serverless environments or edge networks, database connections are established on every request.

This is due to the nature of serverless functions, which do not maintain state between requests and can be spun up or down as needed. Here are some key points to consider:

Serverless Functions:

Next.js uses serverless functions for API routes and server-side rendering (SSR).
Each invocation of a serverless function is stateless and isolated, meaning it doesn't maintain a persistent connection to a database.

Therefore, a new database connection must be established for each request.

import mongoose from "mongoose";

// Object to track connection state
type ConnectionObject = {
    isConnected?: number;
};

// Single connection object to be used across requests
const connection: ConnectionObject = {};

// Function to connect to the database
async function dbConnect(): Promise<void> {
    // Check if already connected to avoid redundant connections
    if (connection.isConnected) {
        console.log("Already Connected");
        return;
    }

    try {
        // Establish a new connection
        const db = await mongoose.connect(process.env.MONGO_URI || "", {
            // Use appropriate options here based on your setup
        });

        // Track the connection state
        connection.isConnected = db.connections[0].readyState;

        console.log("DB is connected");
    } catch (error) {
        console.log("DB connection error:", error);
        process.exit(1); // Exit the process if unable to connect
    }
}

export default dbConnect;

Thank You Me Latter

Difference Between ORM and ODM

Saad Naeem — Wed, 12 Jun 2024 14:27:41 +0000

Hi, Today we will discuss shortly about ORM and ODM tools and we will clear our all confusions of ORM And ODM.

So let's start today's short topic:

ORM:

ORM ( Object relational mapping) is a tool that is commonly used for SQL databases (MYSQL, PostgreSQL).
These tools are used to map the relational database tables into programming language objects.
Examples: Prisma, TypeORM, Sequelize.

ODM:

ODM tool is commonly used for NoSQL Document Database ( MongoDB ).
These tools are used to map the document (JSON Like format ) to programming languages objects.
Examples: Mongoose (for MongoDB).

Exploring TypeScript Decorators: A Deep Dive into Metadata and Annotations

Saad Naeem — Thu, 09 May 2024 10:59:42 +0000

TypeScript decorators are a powerful feature that allows developers to add metadata and behavior to classes, methods, properties, and parameters. In this post, we'll take a deep dive into decorators, exploring their syntax, usage, and the concept of metadata and annotations in TypeScript.

Understanding TypeScript Decorator

Decorators are special expressions that evaluate to a function, which is executed at runtime with information about the decorated declaration. They are prefixed with the @ symbol and can be attached to classes, methods, accessors, properties, or parameters.

function myDecorator(target: any, propertyKey: string): void {
  // Decorator logic
}

class MyClass {
  @myDecorator
  myMethod() {
    // Method implementation
  }
}

Types of Decorators

Class Decorators: Applied to classes, allowing you to modify the class constructor or add metadata to the class.
Method Decorators: Applied to methods, enabling you to modify their behavior or add metadata to them.
Property Decorators: Applied to properties, allowing you to add metadata to class properties.
Parameter Decorators: Applied to method parameters, providing metadata about the arguments of methods.

Working with Metadata and Annotations

One of the most powerful aspects of decorators is their ability to work with metadata and annotations. Metadata is additional information that describes the structure of your code, such as types, interfaces, and classes. Annotations are markers added to code elements to provide additional information.

const MY_METADATA_KEY = Symbol("myMetadataKey");

function myDecorator(target: any, propertyKey: string) {
  Reflect.defineMetadata(MY_METADATA_KEY, "myValue", target, propertyKey);
}

class MyClass {
  @myDecorator
  myMethod() {
    // Method implementation
  }
}

const metadataValue = Reflect.getMetadata(MY_METADATA_KEY, MyClass.prototype, "myMethod");
console.log(metadataValue); // Output: "myValue"

Real-World Use Cases

1.Dependency Injection: Using decorators to mark classes or properties as injectable for dependency injection frameworks.
2.Validation: Adding validation rules to methods or properties using decorators.
3.Logging: Automatically logging method calls or property accesses with decorators.

Conclusion

TypeScript decorators provide a powerful mechanism for adding metadata and behavior to your code. By understanding their syntax and usage, you can leverage decorators to write more expressive, maintainable, and flexible code. Experiment with decorators in your projects to unlock their full potential!