DEV Community: Shreyans Padmani

How PageIndex Rethinks RAG Without Vector Search

Shreyans Padmani — Wed, 03 Jun 2026 17:34:21 +0000

It started with a simple frustration: a RAG system that was fast, scalable, and technically correct — yet still gave answers that felt slightly off. The data was there, embeddings were generated, and vector search was working as expected, but the results often resembled “almost right” instead of precise. Like flipping through a book and landing on pages that are related but not exactly what you need. This is the limitation of traditional vector-based retrieval — it relies on similarity, not certainty. PageIndex challenges this idea by replacing semantic guessing with structured navigation, allowing systems to retrieve exactly the right information, not just the closest match.

What is PageIndex?

PageIndex is an alternative approach to traditional Retrieval-Augmented Generation (RAG) that removes the dependency on vector embeddings and similarity search. Instead of converting text into vectors and storing them in a vector database, PageIndex organizes information in a structured, hierarchical, and page-based format.

ai-agent-development-freelancer

Think of it like a smart book index.

Instead of searching by “semantic similarity” (as in vector search), PageIndex allows the system to navigate directly to the most relevant sections of data using structured references, metadata, and logical grouping.

This makes it:

More deterministic (less guesswork than vector similarity)
Easier to debug and trace
Often more cost-efficient (no embedding or vector DB overhead)

How PageIndex Works

1. Data Organization into Pages

Instead of chunking text arbitrarily, data is divided into logical pages.
Each page represents a coherent unit of information — like a section, topic, or document fragment.

For example:

Page 1 → “Introduction to RAG”
Page 2 → “Vector Databases Explained”
Page 3 → “AWS Architecture”
This preserves meaning better than random chunking.

2. Metadata & Index Creation

Each page is enriched with metadata such as:

Titles
Keywords
Tags
Relationships to other pages
An index is then created — similar to how a search engine or book index works.

This allows fast lookup without needing embeddings.

3. Query Understanding

When a user asks a question, the system analyzes the query using an LLM (such as GPT-4 or Claude).

Instead of converting the query into a vector, it:

Extracts intent
Identifies key topics
Maps the query to relevant indexed pages

4. Page Retrieval (No Vector Search)

Using the index, the system directly retrieves relevant pages.

This can involve:

Keyword matching
Metadata filtering
Hierarchical navigation
Because it’s structured, retrieval is:

Faster
More predictable
Easier to control

5. Context Assembly
The retrieved pages are combined into a structured context.

Unlike traditional RAG (which may return loosely related chunks), PageIndex ensures:

Coherent information flow
Logical grouping
Minimal redundancy

6. Response Generation

Finally, the selected pages are passed to an LLM to generate the answer.

Since the context is cleaner and more relevant, the model:

Produces more accurate responses
Reduces hallucinations
Maintains better consistency

Conclusion

PageIndex rethinks RAG by removing vector search and using structured, page-based retrieval for more precise and explainable results. It reduces reliance on semantic similarity, improves accuracy, and offers a simpler, more deterministic way to access relevant knowledge in AI systems.

Naive RAG vs Agentic RAG: The Evolution of Intelligent Retrieval

Shreyans Padmani — Tue, 02 Jun 2026 16:21:21 +0000

Naive RAG retrieves relevant documents and generates answers from them in a single step. Agentic RAG goes further by planning, reasoning, validating information, and performing multiple retrieval cycles when needed. This makes Agentic RAG more accurate, adaptable, and effective for solving complex real-world problems.

rag-in-generative-ai-dynamic-information-access

Naive Retrieval (Naive RAG)

How It Works

User gives a query
Example: “Affordable eco-friendly smartphones under $500.”

Query is converted into embeddings
The system transforms text into vector format.

Similarity Search (Top-K Retrieval)
It searches the vector database and retrieves the closest matching documents.

Chunk Injection (Augmentation)
Retrieved content is directly inserted into the prompt.

LLM Generates Response
The model produces an answer based only on those retrieved chunks.

Limitations
No planning or strategy
No filtering by structured conditions (price, rating, etc.)
No validation or re-ranking
Depends fully on first retrieval
Can produce incomplete or “mid” responses

Agentic Retrieval (Agentic RAG)

How It Works

User Query → Task Understanding
The agent analyzes the intent behind the question.

Deconstruct & Plan
It breaks the request into smaller sub-tasks.
Example:
Filter by price < $500
Filter eco-friendly category
Check customer ratings

Multi-Collection Search
Searches across multiple vector databases if needed.

Aggregate & Re-Rank
Combines results and ranks them based on relevance and constraints.

Observe & Repeat
If results are not sufficient, it refines the search again.

Synthesize Final Answer
Generates a structured, accurate, high-quality response.

Advantages

Strategic planning
Iterative refinement
Better reasoning
More accurate filtering
Higher quality outputs
Handles complex queries better

Conclusion

Naive RAG retrieves information and generates answers. Agentic RAG goes several steps further — it plans, searches intelligently, refines its approach, and synthesizes knowledge before responding.

As AI applications continue to evolve, Agentic RAG is emerging as a key architecture for building more reliable, accurate, and intelligent enterprise AI systems.

official-Website — shreyans.tech/

Building Blocks of RAG on AWS: From Data to Intelligence

Shreyans Padmani — Sun, 31 May 2026 13:37:18 +0000

In the era of generative AI, simply asking a model a question is no longer enough. The real value lies in grounding responses in your own data — documents, databases, and knowledge bases that matter to your business. This is where Retrieval-Augmented Generation (RAG) comes in. For a deeper dive into how RAG enables dynamic access to information, check out my detailed blog here:

Rag-in-gererative-ai-dynamic-information-access

RAG is not just a buzzword; it’s a practical architecture that combines information retrieval with generative AI to produce accurate, context-aware answers. And when it comes to deploying RAG at scale, AWS offers a powerful set of building blocks.

Let’s walk through the story of how a RAG system comes together on AWS.

Data Processing Pipeline: Turning Raw Data into Intelligence
At the heart of any RAG system lies a quiet but critical layer — the data processing pipeline. This is where raw, unstructured information is transformed into something a machine can actually understand, search, and reason over.

Think of it as the backstage crew of a theater production. The audience never sees it, but without it, the show simply wouldn’t work.

A) Storage — The Source of Truth
Every pipeline begins with storage.

Your original documents — PDFs, Word files, logs, HTML pages — are typically stored in Amazon S3. It acts as a durable, scalable data lake where all raw inputs reside.

The key advantage here is simplicity and flexibility:

Store any file type
Scale virtually without limits
Integrate easily with downstream AWS services
At this stage, your data is complete — but not yet usable for semantic search.

B) Chunking — Making Data Digestible
Large documents are split into smaller, meaningful chunks using services like AWS Lambda, Amazon ECS, or Apache Airflow.
Effective chunking ensures semantic continuity, adds slight overlap for context, and preserves metadata — all of which directly impact retrieval quality.

C) Embedding API — Converting Text into Meaning
Chunked text is converted into vector embeddings using Amazon Bedrock (e.g., Titan models).
This transforms text into numerical representations where similar meanings are closer in vector space, enabling semantic search instead of keyword matching.

D) Vector Store — Building Searchable Memory
Embeddings are stored in Amazon OpenSearch Service for fast similarity search.
It allows scalable storage, quick retrieval, and management of millions of vectors along with metadata.

E) Vector Search — Finding What Matters
User queries are embedded and matched against stored vectors in Amazon OpenSearch Service to retrieve the most relevant chunks.
Accurate results depend on clean data, effective chunking, and high-quality embeddings.

Generic RAG Architecture

Data Processing Pipeline (Generic RAG)
A) Storage — Centralized Data Foundation
Store raw documents in scalable systems such as cloud storage, databases, or document repositories. This layer acts as the single source of truth for all downstream processing.

B) Chunking — Structuring Unstructured Data
Pre-process and split documents into semantically meaningful chunks using tools like LangChain or LlamaIndex.
Well-designed chunking preserves context, introduces overlap, and significantly improves retrieval accuracy.

C) Embedding API — Semantic Transformation
Convert text chunks into dense vector embeddings using advanced embedding models.
This step encodes meaning into numerical space, enabling similarity-based retrieval beyond keyword matching.

D) Vector Store — Efficient Knowledge Indexing
Store and index embeddings in vector databases such as Pinecone, Weaviate, FAISS, or Chroma.
These systems enable fast, scalable, and low-latency search over large datasets.

E) Vector Search — Context Retrieval Engine
Perform semantic search using similarity metrics like cosine similarity or dot product to fetch the most relevant chunks.
This ensures the model receives precise, context-rich information for response generation.

F) Prompt Engineering — Guiding the Model
Design structured prompts that combine user queries with retrieved context.
Clear instructions and formatting help reduce hallucinations and improve response reliability.

G) LLM Selection — Choosing the Right Model
Select an appropriate LLM such as GPT-4, Claude, Llama 3, or Mistral based on performance, cost, latency, and use case requirements.

H) API Layer — System Integration
Expose the RAG pipeline via APIs built with frameworks like FastAPI or Flask.
This layer connects your backend intelligence to frontend applications, enabling real-time interaction.

Conclusion

Retrieval-Augmented Generation (RAG) is more than just connecting a model to data — it’s about designing a pipeline that turns raw information into reliable intelligence. From structured storage and smart chunking to embeddings, vector search, and LLM-powered responses, each building block plays a critical role in the system’s accuracy and performance.

A well-architected RAG system doesn’t just generate answers — it delivers context-aware, trustworthy insights grounded in real data. As organizations continue to adopt AI, mastering these building blocks will be key to building scalable, efficient, and production-ready applications.

Official Website — shreyans.tech

Different Between of MVC controller and APIController

Shreyans Padmani — Sun, 08 Mar 2026 11:21:42 +0000

In ASP.NET Core, both MVC Controllers and API Controllers handle HTTP requests, but they serve different purposes and are used in different application architectures. (Link — https://shreyans.tech/computer-vision-development-freelancer)

MVC Controller(ASP.Net MVC)

1️⃣ Handles HTTP Requests
Receives incoming browser requests and decides how to respond.

2️⃣ Returns Views (HTML)
Primarily used to return Razor Views (.cshtml) to render UI pages.

3️⃣ Inherits from Controller Class
Provides built-in support for views, model binding, TempData, and ViewBag.

4️⃣ Part of MVC Pattern
Acts as the middle layer between Model (data/business logic) and View (UI).

5️⃣ Supports Action Methods
Public methods inside the controller are called action methods and respond to routes.

6️⃣ Model Binding Support
Automatically binds form data, query strings, and route values to model objects.

7️⃣ ViewData, ViewBag & TempData
Used to pass data from Controller to View.

8️⃣ Supports Filters
Allows use of Action Filters, Authorization Filters, and Exception Filters.

9️⃣ Routing Integration
Works with ASP.NET routing to map URLs to specific controller actions.

🔟 Best for Server-Rendered Applications
Ideal for traditional web applications where the server generates HTML pages.

API Controller(ASP.Net Web API)

1️⃣ Designed for RESTful APIs
Handles HTTP requests and returns data (JSON, XML) instead of HTML views.

2️⃣ Inherits from ControllerBase
Lightweight base class optimized for API scenarios without view support.

3️⃣ Uses [ApiController] Attribute
Enables automatic model validation, binding, and better API conventions.

4️⃣ Returns Action Results or Data Objects
Common return types include IActionResult, ActionResult, or raw objects serialized to JSON/XML.

5️⃣ Supports Routing via Attributes
Uses [Route("api/[controller]")] and [HttpGet], [HttpPost] for endpoint mapping.

6️⃣ Automatic Model Binding & Validation
Request bodies are automatically bound to models, and invalid models trigger HTTP 400 responses.

7️⃣ Supports HTTP Methods Explicitly
Action methods can handle GET, POST, PUT, DELETE, PATCH using attributes.

8️⃣ Ideal for Frontend & Mobile Integration
APIs are consumed by Angular, React, mobile apps, or other services.

9️⃣ Stateless by Nature
API Controllers generally do not maintain session or state, following REST principles.

🔟 Supports Filters & Middleware
Can use authentication, authorization, exception handling, and logging filters for API behavior.

Conclusion

In ASP.NET, MVC Controllers and API Controllers serve different purposes. MVC Controllers are designed to render UI views for traditional web applications, while API Controllers are optimized for data-centric RESTful APIs, returning JSON or XML.

Official Website — shreyans.tech

How to build Multi-Tenant app with EF Core

Shreyans Padmani — Sun, 08 Mar 2026 11:14:00 +0000

Build a multi-tenant app with EF Core by adding TenantId to entities, applying global query filters, resolving tenant per request, isolating data via shared or separate databases, and enforcing secure dependency injection configuration.

EF Query Filters

Global Filtering
Automatically apply conditions to all queries for an entity (e.g., soft delete, multi-tenancy).

Defined in OnModelCreating
Configured using HasQueryFilter() inside the DbContext model builder.

Soft Delete Support
Commonly used to filter out records where IsDeleted = true.

Multi-Tenant Isolation
Filters data by TenantId to ensure users access only their tenant’s data.

Automatically Applied
No need to manually add Where clauses in every query.

Can Be Disabled Temporarily
Use IgnoreQueryFilters() when you need to bypass global filters.

**Supports Parameters
**Filters can use context-level variables (e.g., current tenant or user ID).

Improves Security & Consistency
Reduces risk of accidental data exposure and keeps filtering logic centralized.

Example

EF + Dynamic Connection String Resolution

Tenant-Based Database Selection
Dynamically choose a connection string based on the current tenant.

Supports Multi-Tenant Architecture
Enables separate databases per tenant for stronger data isolation.

Resolve Per Request
Determine the connection string from request data (subdomain, header, JWT claim).

Use DbContextOptionsBuilder
Configure the connection string inside OnConfiguring() or during service registration.

Dependency Injection Friendly
Inject a TenantProvider or ConnectionStringResolver service into DbContext.

Improves Security & Scalability
Isolates tenant data and allows independent scaling or migration.

Works with Multiple Providers
Can dynamically switch between SQL Server, PostgreSQL, etc., if required.

Supports Central Configuration Store
Store tenant connection strings in a master database or configuration service.

Requires Careful Lifetime Management
DbContext should be scoped per request to avoid cross-tenant leakage.

Useful for SaaS Applications
Ideal for enterprise SaaS platforms needing strict data separation.

Example

Conclusion

Dynamic connection string resolution in EF Core is a powerful approach for building scalable and secure multi-tenant applications. By resolving the database connection per request, you can ensure proper tenant isolation, improve data security, and enable flexible scaling strategies. When combined with dependency injection and proper DbContext scoping, it becomes a clean and maintainable solution for modern SaaS architectures.

In short, EF Core with dynamic connection string resolution enables true database-level multi-tenancy with flexibility and control.

Why We Use LangChain? — To Smoothly Connect with LLMs

Shreyans Padmani — Sun, 08 Mar 2026 11:05:07 +0000

In today’s AI-driven world, Large Language Models (LLMs) like OpenAI’s GPT models, Google’s Gemini, and Anthropic’s Claude are powerful tools. However, using them effectively in real-world applications requires more than just sending prompts and receiving responses.

What is LangChain ?

LangChain is an open-source Python framework for building application powered by Large Language Models (LLM)

Makes LLM context-aware by integrating external data and tools

Commonly Used for:

Chatbots
Question Answering
Document Analysis
RAG (Retrieval-Augmented Generation)

Why LangChain ?

Out-of-the-box LLM support (OpenAI, Hugging Face, Anthropic, etc.)
APIs
Vector databases (Pinecone, FAISS, Chroma)
Document loaders (PDF, CSV, web scraping)
Supports prompt templates, chains, and agents

How LangChain Works with LLMs

LangChain helps LLMs understand context, remember past interactions, and connect multiple steps to handle complex tasks easily.

Prompt Templates: Define reusable structures for questions or instructions, ensuring consistent and clear communication with the LLM.

Chains: Connect multiple steps or model calls to perform complex reasoning or multi-stage tasks automatically.

Memory: Allows the model to remember previous inputs and responses, giving conversations a continuous and contextual flow.

Agents: Enable the model to decide which action or tool to use next, such as searching data or calling an API.

Conclusion

In a world where Large Language Models (LLMs) are becoming central to modern applications, simply calling an API is no longer enough. We need structure, memory, workflows, and seamless integration with external tools and data sources. LangChain provides that missing layer.

By enabling prompt management, memory handling, Retrieval-Augmented Generation (RAG), and tool integration, LangChain transforms raw LLM capabilities into scalable, production-ready AI systems. Whether you’re building chatbots, AI agents, or data-driven assistants, LangChain helps bridge the gap between powerful models and practical real-world solutions.

In short, we use LangChain to smoothly connect with LLMs — and to turn intelligence into impact.

.NET + AI = The Perfect Combo

Shreyans Padmani — Sun, 08 Mar 2026 10:59:44 +0000

The combination of .NET and Artificial Intelligence creates a powerful foundation for building smart, scalable, and enterprise-ready applications. With the robust ecosystem of ASP.NET Core, developers can seamlessly integrate AI capabilities into web apps, APIs, and cloud solutions.

Using libraries like ML.NET, .NET developers can build, train, and deploy machine learning models directly within their applications — without switching platforms. Integration with cloud platforms such as Microsoft Azure AI further enhances scalability, security, and performance.

Why Choose .NET for AI Development

Cross-Platform & Cloud Friendly

Build once, deploy anywhere: Windows, Linux, Docker, Azure, AWS. Perfect for scalable AI solutions.

Performance & Reliability

.NET is fast and optimized. AI workloads combined with .NET APIs ensure great production performance.

Open Source & Community Support

Huge community, NuGet packages, GitHub Models — rich ecosystem for learning and implementation.

Secure & Enterprise Ready
.NET supports Identity, Dependency Injection, Logging, and Configuration — everything enterprises need for secure AI applications.

What are GitHub Models

GitHub provides pre-hosted AI models that you can use without setting up any GPU or server.

Ready-to-use models (GPT, Phi, LLaMA, etc.)
Runs via API — no infra setup
Great for prototyping AI apps

What is Microsoft.Extensions.AI

A new .NET library that helps developers easily plug AI models (like GitHub Models/OpenAI) directly into their applications with minimal code.

Helps integrate AI like a simple .NET service.
Works with GitHub Models, Azure OpenAI, etc.
Removes complexity of writing APIs manually
You can register AI models in Program.cs using AddAIClient, just like any other .NET service — making it clean and maintainable.

Conclusion

The fusion of .NET and AI empowers developers to build intelligent, scalable, and future-ready applications. By combining the stability of .NET with advanced AI capabilities, businesses can innovate faster, automate smarter, and deliver enhanced user experiences with confidence.

What is Agentic AI ?

Shreyans Padmani — Sun, 08 Mar 2026 10:54:38 +0000

Agentic AI refers to artificial intelligence systems that can act autonomously to achieve goals. Unlike traditional AI that simply responds to prompts, agentic AI can plan, make decisions, take actions, learn from feedback, and adapt to changing environments with minimal human intervention.

What is Agentic AI?

Agentic AI is the next evolution of artificial intelligence — where AI doesn’t just respond but actually acts.

It’s designed to think, decide, and execute tasks on its own, just like a digital assistant that understands goals and takes initiative to achieve them.

Agentic AI can:

Plan actions to reach an objective,
Use tools and APIs to perform real-world tasks,
Adapt using memory and feedback, and
Work continuously without constant human input.

How Agentic AI Works

Agentic AI works like a smart digital brain that can understand goals, plan actions, and execute them — all on its own.

Input Understanding

AI interprets user goals or queries and identifies what needs to be achieved.

Model Reasoning

AI interprets user goals or queries and identifies what needs to be achieved.

Action Execution

The AI performs real-world tasks by interacting with tools, APIs, or systems automatically.

Output Generation

Continuously improves its reasoning and performance through feedback and experience.

Conclusion

Agentic AI represents a powerful shift in artificial intelligence, moving from reactive systems to goal-driven, autonomous agents. By combining reasoning, planning, and adaptability, it enables smarter automation and more efficient problem-solving across industries.

ApiController in .NET

Shreyans Padmani — Sun, 08 Mar 2026 10:48:01 +0000

ApiController in ASP.NET Core is an attribute used for building RESTful web APIs. It enables automatic model validation, parameter binding, and standardized error responses, simplifying controller logic and improving API consistency, reliability, and developer productivity.

ApiController Attribute

The [ApiController] attribute in ASP.NET Core is used to indicate that a controller is intended to serve as an API endpoint.

It simplifies the development of RESTful APIs.

Attribute routing requirement
Automatic HTTP 400 responses
Binding source parameter inference
Problem details for error status codes

Example

Key Features of [ApiController]

1 . Attribute Routing Requirement

Applying the [ApiController] attribute enforces attribute routing. This means that actions within the controller will not be accessible via conventional routing methods (like UseEndpoints or UseMvcWithDefaultRoute). You must use the [Route] attribute on the controller or action methods.

2 .Default Bad Request Response (Problem Details)

The default response type for an HTTP 400 response is ValidationProblemDetails, which conforms to the RFC 7231 standard for problem details.

3 . Automatic HTTP 400 Responses

When model validation fails, the [ApiController] attribute automatically handles the response, returning an HTTP 400 Bad Request status.

4 . Binding Source Parameter Inference

The [ApiController] attribute automatically determines the source of certain action parameters, meaning you often don’t need to explicitly use binding attributes like [FromBody] or [FromQuery].

Conclusion

In conclusion, ApiController in ASP.NET Core streamlines API development by providing automatic validation, binding, and error handling. It reduces boilerplate code, enforces best practices, and enhances consistency, making it essential for building robust and maintainable web APIs.

Middleware Deep Drive in .NET

Shreyans Padmani — Sun, 08 Mar 2026 10:25:55 +0000

Middleware in .NET acts as a request pipeline component that handles logging, authentication, routing, and error handling. Each middleware processes HTTP requests and responses sequentially, enabling modular, reusable, and scalable application architecture within ASP.NET Core applications.

Code Snippet : app.Use(…)

Middleware is the backbone of ASP.NET Core request pipeline.

Executes in pipeline order
Can block, modify, or continue the request
Handles cross-cutting concerns like Logging, Auth, Exception Handling
Inline middleware is the simplest way to inject logic directly in Program.cs.
Use inline middleware for quick checks, lightweight logging, or debugging.

Why Middleware Order Matter

Sequential Request Flow: Middleware executes in the order added; order matters for dependencies.
Reverse Response Flow: Response passes through middleware in reverse order; placement affects response modification.
Short-Circuiting: Middleware like UseAuthentication can stop later middleware from running.
Security & Error Handling: UseExceptionHandler should be first; authentication must run before authorization.
Order impact middleware behavior. Authentication must be before Authorization.

Creating Custom Middleware

RequestDelegate Dependency: Middleware receives a RequestDelegate to invoke the next component.
InvokeAsync Method: Core logic resides in InvokeAsync(HttpContext context).
Short-Circuiting: Middleware can stop the pipeline by not calling await _next(context).
Passing Control: Call await _next(context) to continue to the next middleware.
Registration: Use app.UseMiddleware() to add it to the pipeline.

What Can Middleware Actually Do?

Logging and diagnostics: Middleware can run at the beginning of the pipeline to log request details (timing, path, user) and at the end to log response details (status code, duration).

Blocking suspicious IPs: It can inspect the source IP address of a request and immediately short-circuit the pipeline, preventing malicious or unwanted traffic from reaching the core application.

Injecting headers (e.g., CORS): Middleware is used to modify the HTTP response by adding or changing headers, such as setting CORS (Cross-Origin Resource Sharing) headers to allow external domains to access resources.

Authentication/Authorization:Authentication identifies the user (e.g., reads a token or cookie).Authorization checks if the identified user has permission to access the requested resource.

Request throttling: This involves limiting the number of requests a client can make over a certain period to prevent abuse or overload, often implemented by inspecting rate limits before passing the request further.

Error Handling: Early-registered middleware can catch exceptions thrown by all subsequent components and generate a formatted, user-friendly error response.

Conclusion

Middleware is the backbone of ASP.NET Core’s request pipeline, enabling clean architecture, flexibility, and scalability. By structuring components efficiently, developers can build secure, maintainable, and high-performance .NET applications tailored for modern, AI-integrated systems.

BigQuery vs Traditional Database

Shreyans Padmani — Sun, 08 Mar 2026 10:20:18 +0000

Google BigQuery is a serverless, scalable data warehouse built for analytics on massive datasets, while traditional databases like MySQL handle structured transactions efficiently. BigQuery excels in big data processing; traditional databases suit operational, real-time applications.

Difference Between BigQuery and Traditional Databases

What is BigQuery

BigQuery is a serverless cloud data warehouse by Google, designed for fast analytics and big data processing, capable of analyzing terabytes to petabytes of data in seconds.

1 . Serverless & Fully Managed

No need to manage servers or infrastructure.
Google automatically takes care of scaling, performance, and maintenance.

2 . Massive Scalability

No need to manage servers or infrastructure.
Google automatically takes care of scaling, performance, and maintenance.

3 . Blazing-Fast SQL Queries

Supports simple SQL syntax but runs queries super fast.
Uses a distributed system to process data in parallel.

4 . Cost-Effective (Pay-as-You-Go)

Pay only for the data you store and the queries you run.
No server setup cost or maintenance fees.

5 . Real-Time Analytics

Analyze live data streams in near real-time.
Great for dashboards, monitoring, and instant insights.

What is Traditional Databases

Traditional databases like MySQL, PostgreSQL, and Oracle are RDBMS designed for OLTP, handling day-to-day transactions and CRUD operations efficiently.

1 . Structured Data Storage

Stores data in tables with rows and columns using a fixed schema.
Best for organized and relational data.

2 . Self-Managed Infrastructure

Requires setting up and managing servers, backups, and scaling manually.
Needs regular maintenance and performance tuning.

3 . Optimized for Transactions

Great for CRUD operations (Create, Read, Update, Delete).
Handles real-time transactions like orders, payments, and logins.

4 . Limited Scalability

Works well with small to medium-sized data.
Scaling large data often requires more hardware and complex setups.

5 . Application-Focused Use Cases

Commonly used for web apps, user management, financial systems, and business operations.

Conclusion

Google BigQuery is a powerful, scalable, and serverless data warehouse designed for large-scale analytics. It simplifies big data processing, reduces infrastructure management, and delivers fast insights, making it ideal for modern business intelligence and data-driven decision making.

Stop using try-catch in every controller in C#

Shreyans Padmani — Sun, 08 Mar 2026 10:13:10 +0000

Stop using try-catch in every controller. Instead, use global exception handling and middleware to manage errors centrally. This keeps controllers clean, improves maintainability, ensures consistent responses, and follows best practices in modern web application architecture.

Problem: Try-Catch in Every Controller

Every controller duplicates the same try-catch block.
Controllers mix business logic, error handling, and logging.
Any change to error handling requires editing multiple controllers.
Different developers return different error formats or status codes.
You can’t isolate logic easily due to embedded exception handling.
Adding new exception types means rewriting every controller again.

Solution : Middleware Code(ExceptionMiddleware)

This middleware catches all unhandled exceptions in the request pipeline, so you don’t need to use try-catch in every controller.
It logs the error using ILogger, making debugging and monitoring easier.

Register the Middleware

Registers the custom middleware in the request pipeline so it runs on every request.
Ensures global exception handling by catching unhandled errors before they reach the response.

Benifits

You don’t need to write try-catch in every controller.
All errors are handled in one place, making the code clean and simple.
It gives the same type of error response every time.
Easy to find and fix problems because all exceptions are logged.
Makes the application more secure by not showing detailed error messages to users.
Improves maintenance since error handling logic is centralized.

Conclusion

In conclusion, avoid placing try-catch blocks in every controller. Use centralized exception handling to keep code clean, consistent, and maintainable while ensuring better error management and improved application architecture.