Forem: Naimul Karim

Basic Features of Calude AI

Naimul Karim — Sun, 19 Apr 2026 19:15:20 +0000

As of 2026, Claude AI has evolved from a simple chatbot into a highly capable "agentic" assistant. Through features like Claude Code, Claude Cowork, and the Model Context Protocol (MCP), its day-to-day use cases have expanded significantly beyond just writing and answering questions.

1. Conversation Import

Import chats or data from external sources (e.g., ChatGPT, documents)

Examples:

Import a ChatGPT conversation and summarize key points

2. Structured Prompting

Guided Chat / Structured Prompting (AIM) in Claude AI is a simple way to interact with AI using a clear structure instead of random prompts. It helps users interact more effectively with the AI.

Action → What you want the AI to do
Intent → Why you need it (context or goal)
Method → How the output should be structured or delivered

Examples:

Action: Plan a weekend family trip. Intent: Relaxing, budget-friendly 2-day getaway. Method: Provide a structured itinerary with activities, food options, time schedule, and estimated costs.

3. Skills

Instead of asking random questions, you shape Claude into a role like:
tutor, planner, coach, assistant, or writer

Examples:

Claude as Fitness Coach

Skill customization:
“Act as a beginner fitness coach. Create safe, simple home workout plans with no equipment and focus on consistency.”

Daily workout routines
Weight loss or general fitness plans
Adjusting intensity over time

4. Connectors

Integrate Claude to external tools, APIs, or data sources.

Examples :

Connect to Gmail to summarize inbox, draft replies or send emails
Connect to Google Drive to read and summarize documents
Pull data from spreadsheets and generate insights or summaries
Integrate with calendars to help plan schedules

5. Projects

Projects let you create separate workspaces for different tasks, each with its own chats and information. Inside a project, you can upload files, add context, and have focused conversations with Claude AI.

Examples :

Organize tasks, files, and conversations into projects
Personal Finance Workspace

Budget planning notes
Expense summaries
Investment research
Tax-related questions

6. Artifacts (Generated Outputs)

Artifacts turn a conversation into a finished output you can directly use, not just an explanation. It can generate structured outputs like code, documents, UI components.

Examples :

Build a simple website or landing page (HTML/CSS or React structure)
Generate a project report or business document

7. Collaboration Mode (Co-work)

Claude Cowork is a desktop tool. It connects Claude directly to your computer, files, apps, workflows. It can handle files, folders, and desktop automation tasks.

Examples :

Working together on documents, plans, and structured outputs
Managing files, folders, and project-related content

LLM vs RAG

Naimul Karim — Thu, 16 Apr 2026 02:38:57 +0000

LLM (Large Language Model)

An LLM like GPT-4 or Claude is:

A pretrained model on massive text data
Generates answers based on what it has learned during training
Doesn’t know your private or real-time data unless provided in the prompt

Limitation:

Can hallucinate
Knowledge is static (cutoff-based)

RAG (Retrieval-Augmented Generation)

RAG is a system design pattern, not a model.

It works like this:

User asks a question
System retrieves relevant data (docs, DB, APIs, vector search)
That data is injected into the prompt
LLM generates an answer using that context

LLM can be seen as a generator
RAG is a combination of retriever and LLM

Core Differences

Aspect	LLM	RAG
Type	Model	Architecture / Pattern
Knowledge Source	Training data	External + Real-time data
Accuracy	Can hallucinate	More grounded
Updates	Requires retraining	Just update data source
Use Case	General tasks	Domain-specific, factual Q&A

Without RAG:

User: “What’s the latest interest rate?”
LLM: Might guess or give outdated info

With RAG:

System fetches latest rates from DB/API
LLM answers using that data
Accurate and up-to-date

Usage

Use LLM alone when:

Creative writing
General coding help
Brainstorming

Use RAG when:

You need company data / internal docs
Accuracy matters (finance, legal, healthcare)
Data changes frequently

AI for Developers

Naimul Karim — Wed, 15 Apr 2026 04:47:10 +0000

AI has become a core part of software development, reshaping how developers write code, build systems, and deliver applications through increasingly advanced tools and automation.

Agentic Workflows and Orchestration

n8n helps automate workflows by connecting APIs, services, and AI models into end-to-end processes.

Chat and Assistant Tools

Claude helps with reasoning, long-context understanding, and code-related discussions.
ChatGPT supports developers with coding, debugging, and general problem-solving.
Gemini provides AI assistance across research and multimodal tasks within Google’s ecosystem.

IDE

GitHub Copilot offers real-time code suggestions inside the editor.
Cursor is an AI-native IDE that enables coding through natural language.

Coding Agents

Cursor Agents execute multi-step development tasks autonomously.
GitHub Copilot Agent performs coding tasks beyond simple suggestions.
Codex powers AI-based code generation models.
Claude Code supports advanced coding and problem-solving tasks.
OpenCode runs AI coding agents directly in the terminal.

Full-App Builders

Replit lets users build and deploy apps quickly in the cloud with AI help.
V0 generates frontend components from text prompts.

AI Developer Libraries

LangChain helps build applications powered by large language models.
LangGraph structures AI workflows using graph-based design.
LlamaIndex connects AI models to external data sources.
Haystack builds search and QA systems using LLMs.

Documentation & Knowledge Tools

Problem solving with ML : Domains That Actually Matter

Naimul Karim — Tue, 06 Jan 2026 14:41:58 +0000

When people start learning machine learning, they often focus on different things. But in practice, the most important question is much simpler:

What kind of work do you want to do?

What problems do you want to solve using ML?

When you look at machine learning from this perspective, the entire field can be cleanly divided into five main work domains.

1. Predictive Modeling

This domain works primarily with structured, tabular, or numerical data. The objective is to predict an outcome based on historical patterns.

Examples:

Helping businesses detect and prevent fraud and avoid financial losses
Analyzing effectiveness of past promotional activity
Forecasting patient admissions and readmissions
Predicting energy consumption
Regression, classification, and time-series forecasting all belong here. This is the oldest and most battle-tested area of machine learning, and where most practitioners build their foundation.

2. Perception AI (Vision / Audio)

In this domain, machines learn to interpret visual and auditory signals from the real world.

Examples:

Counting people in public spaces using camera feeds
Detecting cracks or defects in infrastructure from drone images
Recognizing spoken commands in voice-controlled systems
Identifying equipment malfunctions from vibration or sound patterns
Identifying pedestrians and traffic signs in a self-driven car
Models such as CNNs and Vision Transformers (ViT) are heavily used. Perception AI enables machines to convert raw sensory data into meaningful signals.

3. Language Intelligence (NLP)

This domain focuses on understanding and processing written or spoken language.

Examples:

Extracting key clauses from contracts and legal documents
Automatically generating meeting notes from transcripts
Detecting abusive content in online communities
Grouping news articles by topic at scale
Speech recognition, Spell check, autocomplete etc
Transformer-based models like BERT and GPT-style architectures power this domain. The aim is to help machines understand nuance, context, and intent in language.

4. Generative AI (Multimodal)

This domain is about creation, not just prediction. Models here can generate entirely new outputs across multiple data types.

Examples:

Creating a short story based on the style of a particular author,
Generate a realistic image of a person who doesn't exist
Composing a symphony in the style of a famous composer
Generating test cases or documentation from source code
Large Language Models (LLMs), diffusion models, and multimodal systems define this space, where language, vision, and reasoning intersect.

5. Decision & Control Systems (Reinforcement Learning)

What kind of work this is: Learning what action to take in an environment to maximize long-term reward.

Examples:

Dynamic pricing and bidding systems
Recommendation systems with long-term user engagement
Robotics control and motion planning
Resource allocation and scheduling

Agentic AI: The Extension

Agentic AI is an extension, not a standalone ML domain. It builds on Generative AI to enable systems that can reason, plan, and act.

Examples:

An AI assistant that schedules meetings by checking calendars and availability
A system that monitors metrics, detects anomalies, and triggers alerts
An AI agent that runs experiments, compares results, and selects the best approach
Multiple agents collaborating to complete a complex workflow
In short, Agentic AI represents AI systems that don’t just respond but take action.

Unit testing : How to Mock Public Methods in C# with NSubstitute

Naimul Karim — Tue, 06 Jan 2026 02:30:31 +0000

With NSubstitute, a public method can only be mocked if it is virtual (or abstract).
If the method is public but not virtual, NSubstitute cannot mock it.

The options to enables to mock it are :

1. Make the method virtual

This is the Minimal change and fully supported by NSubstitute

public class ProductService
{
    public virtual int GetPrice()
    {
        return 1;
    }
}

var service = Substitute.For<MyService>();
service.GetValue().Returns(42);

2. Extract an interface (cleanest design)

Refactor for Dependency Injection. Refactor your code so that the logic in the method is moved to a dependency (e.g., a helper/service class) that can be mocked. This is the best option.

public interface IProductService
{
    int GetPrice();
}

Inject the interface and mock it instead.

var service = Substitute.For<IProductService>();
service.GetPrice().Returns(42);

3. Use a wrapper / adapter (for third-party or legacy code)

public interface IProductServiceWrapper
{
    int GetPrice();
}

public class ProductServiceWrapper : IProductServiceWrapper
{
    private readonly ProductService _service;
    public int GetPrice() => _service.GetValue();
}

Mock ProductServiceWrapper

Why is offset pagination slow

Naimul Karim — Mon, 05 Jan 2026 00:42:15 +0000

Offset pagination is slow mainly because the database still has to process (read and skip) all the rows before the offset, even though it doesn’t return them.
Since you’re a full-stack engineer working with real production data (likely large tables in fintech systems), this shows up very clearly at scale.
What happens under the hood
A typical offset query looks like:

Sql
SELECT *
FROM transactions
ORDER BY created_at
LIMIT 50 OFFSET 100000;

Step-by-step execution

The database sorts rows by created_at
It reads the first 100,050 rows
It throws away the first 100,000
It returns only 50 rows The work done grows linearly with the offset size

Why it gets slower as page number increases

Rows are scanned, not jumped Databases cannot jump directly to row 100,000. They must:

Traverse the index or table
Count rows until the offset is reached

Even with indexes, the engine still walks through index entries.

Sorting cost increases

If the ORDER BY column:

Is not indexed, the DB must sort everything first
Is indexed, the index traversal still scales with offset Large offsets = more CPU + memory.

Disk I/O increases For large datasets:

Earlier rows may no longer be in cache
Disk reads increase
Latency spikes unpredictably This is especially painful in high-traffic fintech APIs.

Concurrency makes it worse Multiple users requesting: Page 2000 Page 5000 Page 10000

Each query repeats the same expensive skip work
No reuse of previous results

Better alternative: Keyset (Cursor) Pagination

Instead of skipping rows, you continue from the last seen value.


Sql
SELECT *
FROM transactions
WHERE created_at > :last_seen
ORDER BY created_at
LIMIT 50;

Why this is fast

Uses index directly
No skipping
Constant-time performance per page

This is the standard approach for:

Financial transactions
Audit logs
Infinite scroll APIs

When OFFSET is acceptable
OFFSET pagination is okay when:

Tables are small
Page depth is limited (e.g., admin dashboards)
You need random page access (page 3, page 7)

If users can scroll deeply or data grows unbounded don’t use OFFSET

Software Defects Prediction using Machine Learning

Naimul Karim — Wed, 31 Dec 2025 00:22:01 +0000

Step 1: Data Loading and Initial Analysis

This Python 3 environment comes with many helpful analytics libraries installed

It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python

For example, here's several helpful packages to load

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import StandardScaler
import warnings
warnings.filterwarnings('ignore')

# Input data files are available in the read-only "../input/" directory
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session

# Load the Defects Dataset
train = pd.read_csv('/kaggle/input/train.csv')
test = pd.read_csv('/kaggle/input/test.csv')

# Display first few rows
print("First 5 rows of the training dataset:")
print(train.head())
print("First 5 rows of the test dataset:")
print(test.head())

# Dataset shape
print(f"\nDataset Shape: {train.shape}")
print(f"Number of samples: {train.shape[0]}")
print(f"Number of features: {train.shape[1]}")

print(f"\nDataset Shape: {test.shape}")
print(f"Number of samples: {test.shape[0]}")
print(f"Number of features: {test.shape[1]}")

# Column names and data types
print("\nColumn Information for training dataset:")
print(train.info())

print("\nColumn Information for test datase
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ixeyco56775g18iuo9ac.JPG)t:")
print(test.info())

# Statistical summary
print("Statistical Summary:")
print(train.describe())

#Get the statistical information about the training set
import plotly.express as px
train.describe().T\
    .style.bar(subset=['mean'], color=px.colors.qualitative.G10[2])\
    .background_gradient(subset=['std'], cmap='Blues')\
    .background_gradient(subset=['50%'], cmap='Reds')

# Check for missing values
print("=" * 50)
print("Missing Values Analysis")
print("=" * 50)
missing = train.isnull().sum()
missing_pct = (train.isnull().sum() / len(train)) * 100
missing_train = pd.DataFrame({
    'Missing_Count': missing,
    'Missing_Percentage': missing_pct
})
print(missing_train[missing_train['Missing_Count'] > 0])

# Check for duplicates
print("=" * 50)
print("Duplicate Analysis")
print("=" * 50)
duplicates = train.duplicated().sum()
print(f"Number of duplicate rows: {duplicates}")
print(f"\nDuplicate rows:")
train[train.duplicated(keep=False)].sort_values('id')

# Check target variable distribution
print("\nTarget Variable Distribution:")
print(train['defects'].value_counts())
print(f"\nClass Balance:")
print(train['defects'].value_counts(normalize=True))

# target value count
defects_count = dict(train['defects'].value_counts())
defects_count

#Check for missing (NaN) value
print(train[train.isna().any(axis=1)])

Step 2: EDA

# visualize data distrubution
fig , axis = plt.subplots(figsize = (25,35))
fig.suptitle('Data Distribution', ha = 'center', fontsize = 20, fontweight = 'bold',y=0.90 )
for idx,col in enumerate(list(train.columns)[1:-1]):
  plt.subplot(7,3,idx+1)
  ax = sns.histplot(train[col], color = 'blue' ,stat='density' , kde = False,bins = 50)
  sns.kdeplot(train[col] , color  = 'orange' , ax = ax)

# adjust label names
labels = ['not_defects', 'defects']
# visualize data target
plt.title('Defects Values')
sns.barplot(x = labels ,y = list(defects_count.values()), width = 0.3 , palette = ['blue' , 'orange'])

# visualize correlation
corr = train.corr()
mask = np.triu(np.ones_like(corr))
plt.figure(figsize = (20,10))
plt.title('Correlation Matrix')
sns.heatmap(data = corr , mask = mask , annot = True , cmap = 'coolwarm',annot_kws={"color": "black", "size":9} )

**Step 3 : Data cleaning and preparation**
# convert target to binary encoder
# Encode categorical variables
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
train['defects'] = le.fit_transform(train['defects'])

train.defects.unique()

Handling Missing Values

# Strategy 1: Fill missing values with mean/median
train_cleaned = train.copy()

print("Before filling missing values:")
print(train_cleaned[['i', 'b','lOBlank','uniq_Op','total_Op','branchCount']].isnull().sum())

# Fill numeric missing values with median
#train_cleaned['score'].fillna(train_cleaned['score'].median(), inplace=True)
train_cleaned['i'].fillna(train_cleaned['i'].mean(), inplace=True)
train_cleaned['b'].fillna(train_cleaned['b'].mean(), inplace=True)
train_cleaned['lOBlank'].fillna(train_cleaned['lOBlank'].mean(), inplace=True)
train_cleaned['uniq_Op'].fillna(train_cleaned['uniq_Op'].mean(), inplace=True)
train_cleaned['total_Op'].fillna(train_cleaned['total_Op'].mean(), inplace=True)
train_cleaned['branchCount'].fillna(train_cleaned['branchCount'].mean(), inplace=True)

print("\nAfter filling missing values:")
print(train_cleaned[['i', 'b','lOBlank','uniq_Op','total_Op','branchCount']].isnull().sum())

**Handling Outliers**

# Visualize outliers using box plots
plt.figure(figsize=(12,12))
i=1
for col in train.columns:
    plt.subplot(6,6,i)
    train[[col]].boxplot()
    i+=1

# Detect outliers using IQR method
def detect_outliers_iqr(data, column):
    Q1 = data[column].quantile(0.25)
    Q3 = data[column].quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
    outliers = data[(data[column] < lower_bound) | (data[column] > upper_bound)]
    return outliers, lower_bound, upper_bound

# Detect outliers in age
outliers_b, lower_b, upper_b = detect_outliers_iqr(train_cleaned, 'b')
print(f"b outliers (outside {lower_b:.2f} - {upper_b:.2f}):")
print(outliers_b[['id', 'b']])

#List of numerical columns
num_cols=[col for col in train.columns if (train[col].dtype in ["int64","float64"]) & (train[col].nunique()>50)]
num_cols

#Method to handle outliers
def handle_outliers(
    train,
    columns,
    factor=1.5,
    method="clip"  # "clip" or "remove"
):
    """
    Handle outliers using the IQR method.

    Parameters:
        train (pd.DataFrame): Input DataFrame
        columns (list): List of numeric columns
        factor (float): IQR multiplier (default 1.5)
        method (str): "clip" to cap values, "remove" to drop rows

    Returns:
        pd.DataFrame
    """
    train = train.copy()

    for col in columns:
        Q1 = train[col].quantile(0.25)
        Q3 = train[col].quantile(0.75)
        IQR = Q3 - Q1

        lower = Q1 - factor * IQR
        upper = Q3 + factor * IQR

        if method == "clip":
            train[col] = train[col].clip(lower, upper)
        elif method == "remove":
            train = train[(train[col] >= lower) & (train[col] <= upper)]
        else:
            raise ValueError("method must be 'clip' or 'remove'")

    return train

# Cap outliers 
print(f"Before outlier cleaning: {train_cleaned.shape}")
train_cleaned = handle_outliers(train_cleaned, num_cols, method="clip")
print(f"After outlier cleaning: {train_cleaned.shape}")

Step 4 : Model Building and Prediction

# Separate features and target
X= train_cleaned.drop("defects", axis=1)
y= train_cleaned["defects"]
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.1, random_state = 42, stratify=y)

# Initialize Random Forest Classifier
rf_model = RandomForestClassifier(
    n_estimators=50,
    criterion='gini',
    max_depth=20,
    min_samples_split=10,
    min_samples_leaf=5,
    max_features='sqrt',
    bootstrap=True,
    random_state=42,
    n_jobs=-1
)
# Train the model
rf_model.fit(X_train, y_train)
print("Random Forest model trained successfully!")

# Display model parameters
print("\nModel Parameters:")
print(rf_model.get_params())

Model Evaluation

# Calculate accuracy scores
train_accuracy = accuracy_score(y_train, y_train_pred)
test_accuracy = accuracy_score(y_test, y_test_pred)

print("=" * 50)
print("Accuracy Scores")
print("=" * 50)
print(f"Training Accuracy: {train_accuracy:.4f} ({train_accuracy*100:.2f}%)")
print(f"Testing Accuracy: {test_accuracy:.4f} ({test_accuracy*100:.2f}%)")
print("=" * 50)

# Initialize Decision Tree Classifier
dt_model = DecisionTreeClassifier(
    criterion='gini',
    max_depth=5,
    min_samples_split=20,
    min_samples_leaf=10,
    random_state=42
)

# Train the model
dt_model.fit(X_train, y_train)

print("Decision Tree model trained successfully!")

from sklearn.tree import export_text

tree_rules = export_text(dt_model)
print(tree_rules)

# Make predictions
y_train_pred = dt_model.predict(X_train)
y_test_pred = dt_model.predict(X_test)

print("Predictions completed!")

# Calculate accuracy scores
train_accuracy = accuracy_score(y_train, y_train_pred)
test_accuracy = accuracy_score(y_test, y_test_pred)

print("=" * 50)
print("Accuracy Scores")
print("=" * 50)
print(f"Training Accuracy: {train_accuracy:.4f} ({train_accuracy*100:.2f}%)")
print(f"Testing Accuracy: {test_accuracy:.4f} ({test_accuracy*100:.2f}%)")
print("=" * 50)

#linear Regression
def lr(X_train, X_test, y_train, y_test):
    model = LinearRegression()
    model.fit(X_train, y_train.values.ravel())
    y_pred = model.predict(X_test)
    error = mean_squared_error(y_test, y_pred)
    print(f"Score: {error}")
    return model

Submission

#Submission
X_test = test[X_train.columns]
y_test_pred = rf_model.predict(X_test)
submission = pd.DataFrame({
    "id": test["id"],
    "defects": y_test_pred
})
submission.to_csv("submission.csv", index=False)
submission

How to control the log level of application

Naimul Karim — Wed, 22 Oct 2025 22:04:06 +0000

ASP.NET (especially ASP.NET Core) supports logging via the built-in Microsoft.Extensions.Logging framework.

The logging verbosity is categorized into the following levels:

1. Trace Most detailed. Includes all diagnostic information. Useful during development or deep debugging.
2. Debug Less detailed than Trace. Used for debugging during development. Not typically enabled in production.
3. Information General flow of the application (e.g., startup, shutdown, user actions). Useful for understanding what the app is doing.
4. Warning Something unexpected or potentially problematic happened, but the app can continue running.
5. Error A failure occurred during the current operation, but the app continues.
6. Critical A fatal error or application crash. The application may be unable to continue running.
7. None Logging is completely disabled.

1. Using appsettings.json

In the Logging section, which is used to configure the logging behavior of your application. The default configuration is :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
    }
  }
}

In the above configuration you can control your default log level and the log level of specific namespaces.
The default log level is applied to all namespaces that are not explicitly configured.
Here the default log level is set to Information and the log level of the Microsoft.AspNetCore namespace is set to Warning. So when you use logger.LogWarning in code, it will be logged, but when you use logger.LogInformation it will not be logged.

Suppose we have a class like this :

namespace ProductsDomain

public class HomeController
{
   private readonly ILogger<HomeController> _logger;

   public HomeController(ILogger<HomeController> logger)
   {
     _logger = logger;
   }

   public IActionResult Index()
   {
    _logger.LogInformation("Index page loaded.");
    _logger.LogWarning("This is a warning.");
    _logger.LogError("An error occurred.");
    return View();
   }
}

Normally if you call the controller method,LogWarning and LogError will not be logged, because the default log level is Information.
But if you change the following LogLevel inside the appsettings.json file, it will be logged:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning",
      "ProductsDomain.HomeController": "Warning"
      "ProductsDomain.HomeController": "Error"
    }
  }
}

So if class name along with namespace is part of the configured namespace inside the appsettings.json file, it will override the default log level. The logger will apply the most specific log level

Steps to Transform ASP.NET Core API into AWS Lambda Functions

Naimul Karim — Wed, 01 Oct 2025 03:09:16 +0000

The beauty of hosting an ASP.NET Core API behind a Lambda function is that you can write an ASP.NET Core API using the skills you already have and AWS's logic will provide a bridge to run each controller same as existing API Controllers.

The below steps will guide you to transform a ASP.Net CoreAPI to a Serverless Application.

*1. Install the AWS Toolkit extension for Visual Studio *

Create the new project, selecting the template ‘AWS Serverless Application (.NET Core)

The below tag will be added to in csproj fileLambda

And the AWS nuget package reference will also be added.Amazon.Lambda.AspNetCoreServer(5.3.0)

3. Configuring Amazon API Gateway

serverless.template: An AWS CloudFormation Serverless Application Model template file for declaring Serverless functions and other AWS resources. It contains one function definition configured to be exposed by API Gateway using proxy integration, so all requests will go to that function. The only thing that needs to be updated is the handler field. The format for the handler field is

::.LambdaFunction::FunctionHandlerAsync

The FunctionHandlerAsync method is inherited from the base class of our LambdaFunction class.

*The Lambda Entry Point *

Amazon.Lambda.AspNetCoreServer.APIGatewayProxyFunction

The code in this file bootstraps the ASP.NET Core hosting framework. The Lambda function is defined in the base class. When the app is run locally, it started with the LocalEntryPoint class. When this is run within the Lambda service in the cloud, this LambdaEntryPoint is what will be used.

Creating the API and service

Copy the codes from existing API and service classes.

Run Locally

Now build and run the project from IIS and see if it works

Check the controller Post and Get responses from postman.

All good locally.

Deploying the WeApi to AWS Lambda

Create an AWS Profile from AWS Explorer in View

Right click your project and select “Publish To AWS Lambda”.
Put a Stack Name and create a S3 Bucket.

Publishing to AWS is in progress.

S3 Bucket is created.

Lambda Function is deployed.

From Cloud Watch Monitor is showing the statistics.

Get the AWS Serverless URL from Visual Studio .

Check the API from postman.

The API is running and returning responses.

You are done !

Registering Multiple Implementations of the same Interface using Autofac vs using Built-In Asp .Net Core DI

Naimul Karim — Wed, 01 Oct 2025 03:01:06 +0000

Using Autofac Keyed Services

Using strings as Key multiple dependencies can be registered.

For example creating a Enum where each enum value corresponds to an implementation of the service:

Public Enum PaymentState { Online, Cash}

The implementations are as below.

public class CardPaymentState : IPaymentState {}
public class CashPaymentState : IPaymentState {}

The enum values can then be registered as keys for the implementations below.

var builder = new ContainerBuilder()

builder.RegisterType<CardPaymentState>().Keyed<IPaymentState>PaymentState.Online);

builder.RegisterType<CashPaymentState>().Keyed<IPaymentState>(PaymentState.Cash);

Now they can be resolved like below.

var cardPayment = container.ResolveKeyed<IPaymentState>(PaymentState.Online)

var cashPayment = container.ResolveKeyed<IPaymentState>(PaymentState.Cash);

*Using .Net Core Built-In DI *

Firstly a shared delegate has to be declared.

Public delegate IPaymentService PaymentServiceResolver(string key);
Then in startup.cs, the multiple concrete registrations and a manual mapping of those types have to be set.

services.AddTransient<CreditCardService>()
services.AddTransient<CashService>();

services.AddTransient<PaymentServiceResolver>(serviceProvider => key =
{
    switch (key)
    {
        case "online":
            return serviceProvider.GetService<CreditCardService>();

        case "cash":
            return serviceProvider.GetService<CashService>();

        default:
            throw new KeyNotFoundException();
    }
});

Now it can be used from any class registered with DI.

public class Payment
{
    private readonly IPaymentService  paymentService;
    public Consumer(PaymentServiceResolver paymentServiceResover)
    {
       paymentService= paymentServiceResover("Online");
    }
    public void PayByCard()
    {
       paymentService.ProcessPayment();
    }
}

Simple steps to build a CI/CD pipeline with ASP.Net Core, GitHub Actions, Docker and a Linux server

Naimul Karim — Wed, 01 Oct 2025 02:56:59 +0000

The Pipeline

Build is run automatically at each commit to GutHub.
A docker container is created and pushed to docker hub.
Finally the container is deployed to a Linux Server.

Build the Application

Create a docker file with the following codes and put it in the same folder as the sln file of your application.

The docker file contains metadata for two images. First one contains a .net sdk to build the application. The second one only contains the ASP.NET Core runtime and application binaries to be used for production deployment.

Run the docker container locally

Run the following commands to see your docker container is created and running in your machine.

docker build . -t cicddemo

docker run -p 5000:80 -it cicddemo

This will create a container from the image. Check your webpage from http://localhost:5000

Also can check from docker desktop if the containers are running.

Commit and push to GitHub

If the page is loading, commit all changes and push everything to GitHub.

Build the container with GitHub Actions and push it to Docker Hub

1.Set Secrets for your docker hub username and password.

Create the directory “.github/workflows” in the root of your git repository. Inside this folder, add a file called “cicddemo.yaml”. My cicddemo.yaml contains the following :

3.Save this file to “.github/workflows/CICD.yaml” , commit all changes and push them to GitHub.

Now if you look into your GitHub account, you should see the workflow under the “Actions” tab. And if you click you will find your jobs running.

After it is completed login to your docker hub account and you will find the image under your repository.

No alt text provided for this image
You are done !

Integrating Datadog in .NET Project using Serilog

Naimul Karim — Wed, 01 Oct 2025 02:52:50 +0000

In modern cloud-native and microservices architectures, applications are highly distributed, making it difficult to detect failures and performance bottlenecks and monitoring and analytics tools are essential to ensure the performance and reliability of web services and applications. Among these tools, Datadog is a popular choice. Its is a cloud-based monitoring and security platform that provides real-time observability for applications, infrastructure, logs, and security across distributed systems. It integrates with cloud providers, containers, databases, and third-party services, allowing teams to track performance, troubleshoot issues, and ensure system reliability.

Here’s how it can be set up:

Required Nuget Packages

Serilog.AspNetCore Serilog logging for ASP.NET Core
Serilog.Sinks.Datadog.Logs A Serilog sink that sends events and logs straight away to Datadog. By default the sink sends logs over HTTPS

Step 1 : Sign up for a Datadog account

Also note the region of your Datadog site. In my case it was US5 (us5.datadoghq.com)

Step 2 : Get the API Key

Get the API key from Data log portal

Step 3 : Get the Logging Endpoints

Use the site selector dropdown on the right side of the page to see supported endpoints by Datadog site (https://docs.datadoghq.com/logs/log_collection/?tab=host#supported-endpoints). This is needed in configuration URL of appsettings.

Step 4: Configure Serilog and Datadog in appsettings.json

In apssettings.json add the necessary configuration for Serilog and Datadog. The following set up includes specifying sinks for the console and Datadog, setting minimum log levels, defining service properties and the enrichment of logs.

Step 5: Initialize Serilog in Program.cs

The following code reads the configurations from appsettings.json and adds serilog to the logging providers.

Step 6: Use Logging in Controller and Services

Finally create logs by injecting the ILogger logger into the class where you want to use it. Hit your api controller.

Step 7: View logs in Datadog

Go to Datadog portal and then navigate to Logs -> Explorer to view logs.

Done!

Thanks for reading !