Day 1: Intro to MLOps: ML Meets DevOps: https://lxop.in/day1
Day 2: MLOps Tools Landscape: https://lxop.in/day2
Day 3: Data Versioning with DVC: https://lxop.in/day3
Day 4: Reproducible ML environments (Conda & Docker): https://lxop.in/day4
Day 5: Feature Engineering & Feature Stores: https://lxop.in/day5
Day 6: Training ML Models with Scikit-learn & TensorFlow: https://lxop.in/day6
Day 7: Model Experiment Tracking with MLflow: https://lxop.in/day7
Day 8: Model Evaluation & Metrics: https://lxop.in/day8
Day 9: ML Pipelines with Kubeflow Pipelines — https://lxop.in/day9
Day 10: Serving ML Models with FastAPI & Flask: https://lxop.in/day10
Day 11: Packaging Models with Docker: https://lxop.in/day11
Day 12: CI/CD for ML with GitHub Actions: https://lxop.in/day12
Day 13: ML Model Deployment: https://lxop.in/day13
Day 14: Data Drift & ML Model Drift Detection : https://lxop.in/day14
Day 15: Automated Retraining ML Pipelines: https://lxop.in/day15
Day 16: Security in MLOps: https://lxop.in/day16
Day 17: Explainable AI (XAI) in Production: https://lxop.in/day17
Day 18: ML Model Governance & Compliance: https://lxop.in/day18
Day 19: Monitoring ML Systems in Production: https://lxop.in/day19
Day 20: Model Registry: https://lxop.in/day20
Day 21: Scaling ML Model Inference with Kubernetes: https://lxop.in/day21
Day 22: MLOps with ML Platforms: https://lxop.in/day22
Day 23: Managing LLMs in Production: https://lxop.in/day23
Day 24: Agentic AI & RAG: https://lxop.in/day24
Day 25: MCP Explained for MLOps Engineers: https://lxop.in/day25
Day 26: Project: End-to-End MLOps Pipeline: https://lxop.in/day26
Day 27: Model Deployment with Serverless Architectures: https://lxop.in/day27
Day 28: Cost & Performance Tuning in MLOps: https://lxop.in/day28
Day 29: Disaster Recovery & HA for ML Systems: https://lxop.in/day29
Day 30: MLOps Interview Question & Answers: https://lxop.in/day30

Hey there, this is Sandip Das, with 12+ years of experience. I thought, why not write awesome guide content for my fellow Cloud & DevOps Engineers and make it available for a very affordable price point, and it turned out to be one of the best things I have ever done.

Check out these ebooks and give them a read:

Ebook#1: Linux Master Handbook
Ebook#2: Shell Scripting Handbook
Ebook#3: Kubernetes Handbook
Ebook#4: Kubernetes Troubleshooting Handbook
Ebook#5: Kubernetes Production Guide on AWS
Ebook#6: Terraform Masterbook
Ebook#7: Freelance Masterbook

All these ebooks and all future ebooks you will get if you become a LearnXops Premium Member for a very minimal cost.

What is 60 Days of DevOps?

“60 Days of DevOps” is a structured, community-driven learning challenge. It provides a curated, hands-on journey through the essential tools, practices, and mindsets that define modern DevOps and Cloud Engineering.

Each day focuses on a specific topic, ranging from foundational concepts like version control and containerization to advanced subjects such as Kubernetes, GitOps, observability, infrastructure as code, security, and platform engineering. The series includes theoretical knowledge, real-world tasks, curated resources, and challenges for self-assessment.

Motivation Behind 60 Days of DevOps

I observed a common problem: aspiring and practicing engineers often lacked a structured path to master DevOps. Most online resources are fragmented, tool-specific, or theoretical without real-world context. This created confusion, burnout, or slow progress for learners.

The motivation was to:

• Create a cohesive and progressive learning journey that reflects how DevOps works in real environments.
• Provide a daily habit of learning, which builds consistency and retention.
• Bridge the gap between theory and production-grade implementation.
• Share hands-on tasks and open-ended challenges to build practitioner skills.
• Empower individuals to move from DevOps basics to platform engineering and SRE roles.

Goal of 60 Days of DevOps (5 E’s)

1. Educate engineers on real-world DevOps tools, concepts, and workflows.
2. Enable hands-on learning through implementation-focused tasks.
3. Encourage consistency by breaking the journey into manageable daily segments.
4. Elevate DevOps maturity from beginner to expert, including platform and SRE practices.
5. Engage the community to share knowledge, experiences, and grow together.

Here’s the full list of #60DaysOfDevOps

Day 1: Linux Basics — Commands, File System, Users & Permissions

🔗 https://www.learnxops.com/linux-basics-commands-file-system-users-permissions-challange

Day 2: Linux Shell Scripting & Automation

🔗 https://www.learnxops.com/linux-shell-scripting-automation-challenge

Day 3: Git & GitHub — Basics, Branching, Merging, PRs

🔗 https://www.learnxops.com/git-github-basics-branching-merging-prs-challange

Day 4: Git Advanced — Rebase, Cherry-pick, Conflict Resolution

🔗 https://www.learnxops.com/git-advanced-rebase-cherry-pick-conflict-resolution

Day 5: Python Basics for DevOps

🔗 https://www.learnxops.com/python-basics-for-devops

Day 6: Advanced Python for DevOps

🔗 https://www.learnxops.com/advanced-python-for-devops

Day 7: AWS Cloud Automation with Python & Boto3

🔗 https://www.learnxops.com/aws-cloud-automation-with-python-boto3

Day 8: Docker Basics

🔗 https://www.learnxops.com/docker-basics

Day 9: Docker Networking, Volumes, and Compose

🔗 https://www.learnxops.com/docker-networking-volumes-and-compose

Day 10: Building & Running Multi-Arch Docker Containers

🔗 https://www.learnxops.com/building-running-multi-arch-docker-containers

Day 11: Making Docker Containers Production-Ready

🔗 https://www.learnxops.com/making-docker-containers-production-ready

Day 12: Docker Mini Projects — Applying What We Learned

🔗 https://www.learnxops.com/docker-mini-projects-applying-what-we-learned

Day 13: AWS Global Infrastructure & EC2 Basics

🔗 https://www.learnxops.com/aws-global-infrastructure-ec2-basics

Day 14: AWS EC2 Real-Life Challenges

🔗 https://www.learnxops.com/aws-ec2-deep-dive-real-life-challenges

Day 15: AWS VPC: Secure, Scalable, and Private Cloud Networking

🔗 https://www.learnxops.com/aws-vpc-secure-scalable-and-private-cloud-networking

Day 16: AWS IAM: Identity and Access Management

🔗 https://www.learnxops.com/aws-iam-identity-and-access-management

Day 17: AWS S3 for DevOps

🔗 https://www.learnxops.com/aws-s3-for-devops

Day 18: AWS ECS: Run and Scale Containerized Applications Effortlessly

🔗 https://www.learnxops.com/aws-ecs-run-and-scale-containerized-applications-effortlessly

Day 19: AWS RDS: Managed Relational Databases

🔗 https://www.learnxops.com/aws-rds-managed-relational-databases

Day 20: Amazon DynamoDB: Serverless NoSQL DB at any scale

🔗 https://www.learnxops.com/amazon-dynamodb-serverless-nosql-db-at-any-scale

Day 21: Ansible Basics

🔗 https://www.learnxops.com/ansible-basics

Day 22: Ansible Playbook — Deep Dive

🔗 https://www.learnxops.com/ansible-playbook-deep-dive

Day 23: Ansible Vault & Secrets Management

🔗 https://www.learnxops.com/ansible-vault-secrets-management

Day 24: Jenkins Basics

🔗 https://www.learnxops.com/jenkins-basics

Day 25: Jenkins Pipeline Deep Dive

🔗 https://www.learnxops.com/jenkins-pipeline-deep-dive

Day 26: GitHub Actions Basics

🔗 https://www.learnxops.com/github-actions-basics

Day 27: GitHub Actions — Advanced Workflows

🔗 https://www.learnxops.com/github-actions-advanced-workflows

Day 28: Kubernetes Basics & Architecture + Easy Local Setup (Minikube & Kind)

🔗https://www.learnxops.com/kubernetes-basics-architecture-easy-local-setup-minikube-kind/

Day 29: Kubernetes Namespace

🔗 https://www.learnxops.com/kubernetes-namespace/

Day 30: Kubernetes Pods

🔗 https://www.learnxops.com/kubernetes-pods/

Day 31: Kubernetes Deployments — Scale, Roll, and Recover Like a Pro

🔗 https://www.learnxops.com/kubernetes-deployments-scale-roll-and-recover-like-a-pro/

Day 32: Kubernetes Services — Exposing and Connecting Workloads

🔗 https://www.learnxops.com/kubernetes-services-deep-dive-exposing-and-connecting-workloads/

Day 33: Kubernetes StatefulSets — Stable Identity, Persistent Pods

🔗 https://www.learnxops.com/kubernetes-statefulsets-stable-identity-persistent-pods/

Day 34: Kubernetes DaemonSets — Run on Every Node

🔗 https://www.learnxops.com/kubernetes-daemonsets-run-on-every-nodes/

Day 35: Kubernetes Jobs & CronJobs — Automate One-Time & Scheduled Tasks

🔗 https://www.learnxops.com/kubernetes-jobs-cronjobs-automate-one-time-scheduled-tasks/

Day 36: Kubernetes Operators & CRDs Made Simple: Automate Like a Pro

🔗 https://www.learnxops.com/kubernetes-operators-crds-made-simple-automate-like-a-pro/

Day 37: Kubernetes Storage — PV & PVC

🔗 https://www.learnxops.com/kubernetes-storage-pv-pvc/

Day 38: Kubernetes ConfigMaps — Managing Configuration for Your Apps

🔗 https://www.learnxops.com/kubernetes-configmaps-managing-configuration-for-your-apps/

Day 39: Kubernetes Secrets Management — Native & External Integrations

🔗 https://www.learnxops.com/kubernetes-secrets-management-native-external-integrations/

Day 40: Kubernetes RBAC — Secure Access Control

🔗 https://www.learnxops.com/kubernetes-rbac-secure-access-control/

Day 41: Kubernetes Logs — Debug Everything

🔗 https://www.learnxops.com/kubernetes-logs-debug-everything

Day 42: Kubernetes Resource Requests and Limits — Control Resource Usage

🔗 https://www.learnxops.com/kubernetes-resource-requests-and-limits-control-resource-usage/

Day 43: Kubernetes Troubleshooting — Diagnose & Fix Like a Pro

🔗 https://www.learnxops.com/kubernetes-troubleshooting-diagnose-fix-like-a-pro/

Day 44: Kubernetes Scaling — Scale Smarter, Not Harder

🔗 https://www.learnxops.com/kubernetes-scaling-scale-smarter-not-harder/

Day 45: Helm Charts — Kubernetes Package Manager

🔗 https://www.learnxops.com/helm-charts-kubernetes-package-manager/

Day 46: Kubernetes Ingress & Gateway API — Smart Traffic Control

🔗 https://www.learnxops.com/kubernetes-ingress-gateway-api-smart-traffic-control/

Day 47: Kubernetes Ingress & Gateway API — Smart Traffic Control

🔗 https://www.learnxops.com/kubernetes-monitoring-with-prometheus-grafana/

Day 48: Terraform Basics — Infrastructure as Code (IaC) Foundation

🔗 https://www.learnxops.com/terraform-basics-infrastructure-as-code-iac-foundation/

Day 49: Terraform Advanced — Modules, Remote State, Workspaces & More

🔗 https://www.learnxops.com/terraform-advanced-modules-remote-state-workspaces-more/

Day 50: Pulumi — True Infrastructure as Code (IaC) with Real Programming Languages

🔗 https://www.learnxops.com/pulumi-true-infrastructure-as-code-iac-with-real-programming-languages/

Day 51: AWS CDK — Infrastructure as Code with Real Programming Languages

🔗 https://www.learnxops.com/aws-cdk-infrastructure-as-code-with-real-programming-languages/

Day 52: Crossplane — Kubernetes-Native Infrastructure Management

🔗 https://www.learnxops.com/crossplane-kubernetes-native-infrastructure-management/

Day 53: GitOps with ArgoCD — Automating Kubernetes Deployments

🔗 https://www.learnxops.com/gitops-with-argocd-automating-kubernetes-deployments/

Day 54: Production-Grade Secrets Management Using HashiCorp Vault

🔗 https://www.learnxops.com/production-grade-secrets-management-using-hashicorp-vault/

Day 55: Grafana Loki — Scalable, Cost-Effective Logging for Kubernetes and Cloud-Native Systems

🔗 https://www.learnxops.com/grafana-loki-scalable-cost-effective-logging-for-kubernetes-and-cloud-native-systems/

Day 56: Distributed Tracing & Observability for Kubernetes Microservices using Jaeger, OpenTelemetry & Grafana Tempo

🔗 https://www.learnxops.com/distributed-tracing-observability-jaeger-opentelemetry-grafana-tempo/

Day 57: Build Container Images with Cloud Native Buildpacks & VM/Container Images with HashiCorp Packer

🔗 https://www.learnxops.com/build-container-images-with-cloud-native-buildpacks-vm-container-images-with-hashicorp-packer/

Day 58: Chaos Engineering in DevOps — Break Things Before They Break You

🔗 https://www.learnxops.com/chaos-engineering-in-devops-break-things-before-they-break-you/

Day 59: Security in DevOps (DevSecOps) — Building Secure Pipelines and Infrastructure

🔗 https://www.learnxops.com/security-in-devops-devsecops-building-secure-pipelines-and-infrastructure/

Day 60: From DevOps to Platform Engineering & SRE — Building Scalable, Reliable Systems

🔗 https://www.learnxops.com/from-devops-to-platform-engineering-sre-building-scalable-reliable-systems/

🧠 Final Thoughts

DevOps is more than just tooling — it’s a mindset and culture shift. The 60-day challenge is a gateway to structured, real-world learning. Consistency and curiosity are the keys to mastery. Start small, think big, and build daily. Let’s build better systems and stronger communities — together.

Thanks for being an awesome audience and encouraging me to write more on Cloud, DevOps & programming.

On this platform, I have been here for many years and writing to all of you.

Now, that I have an official site, all upcoming posts, articles, and videos will be there only.

Please feel free to visit https://www.learnxops.com/ and learn DevOps, DevSecOps, CloudOps, MLOps, AIOps …..XOps

Any ML Model training requires good data and the first step in MLOps flow is to automate data extraction, validation, and preparing data for ML Model training!

Let’s break down each topic: Data Extraction, Validation & Preparation with coding examples to understand this even better way:

Data extraction

— — — — — — — — — — — -

Data extraction involves retrieving data from sources such as databases, APIs, flat files, or web scraping. Important considerations include:

Structured Data Sources (Well-organized data, often in tabular form)

Databases: MySQL, PostgreSQL, Oracle, SQL Server

Data Warehouses: Amazon Redshift, Google BigQuery, Snowflake

Spreadsheets: Microsoft Excel, Google Sheets

ERP Systems: SAP, Oracle ERP, Microsoft Dynamics

Semi-Structured Data Sources (Organized but not in traditional tables)

APIs: REST, GraphQL, SOAP (e.g., Twitter API, Google Maps API) JSON/XML

Files: Logs or configuration files in cloud platforms

Email Systems: Extracting structured data from emails using IMAP, SMTP

NoSQL Databases: MongoDB, Cassandra, Redis

Unstructured Data Sources (Raw data without predefined structure)

Documents: PDFs, Word files

Media Files: Images, audio, video

Web Scraping: Extracting data from websites (e.g., BeautifulSoup for Python)

Logs: System logs, application logs (from sources like AWS CloudWatch, ELK Stack)

Real-Time Data Streams

IoT Devices: Sensors, smart meters

Message Queues: Kafka, RabbitMQ, AWS Kinesis

Social Media Feeds: Live data from platforms like Twitter or Facebook

Manual Data Collection

Surveys: Google Forms, Typeform

User Inputs: Form submissions from web or mobile apps

Cloud-Based Data Sources:

Cloud Storage Services: AWS S3, Google Cloud Storage, Azure Blob Storage SaaS Platforms: Salesforce, HubSpot, Google Analytics

Data Formats:

— — — — — — — — — —

Understand formats (CSV, JSON, XML, etc.).

Automation:

— — — — — — — — —

Use scripts to streamline the process.

e.g.

Sample Data:

We’ll start with a simple CSV file:

csv
user_id,name,email,age
1,John Doe,john.doe@example.com,28
2,Jane Smith,jane.smith@example.com,34
3,Sam Johnson,sam.johnson@example.com,22

Sample script to extract data and work with it:

# Import required libraries
import pandas as pd

# Load CSV data
data = pd.DataFrame({
    'user_id': [1, 2, 3],
    'name': ['John Doe', 'Jane Smith', 'Sam Johnson'],
    'email': ['john.doe@example.com', 'jane.smith@example.com', 'sam.johnson@example.com'],
    'age': [28, 34, 22]
})

# Display extracted data
print("Extracted Data:")
data.head()

Data Validation

— — — — — — — — — — — -

After extraction, validating the data ensures quality and consistency. Important steps include:

• Schema Validation: Ensure proper data types.
• Missing Values: Handle missing entries.
• Outlier Detection: Detect and manage outliers.
• Consistency Checks: Ensure consistency across sources.

Sample Data with Issues

csv
user_id,name,email,age
1,John Doe,john.doe@example.com,28
2,Jane Smith,jane.smith@example.com,
3,Sam Johnson,,22
4,Emily Davis,emily.davis@example.com,120

Python Script to validate:

import pandas as pd

# Introducing issues in data
data_with_issues = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 4],
    'name': ['John Doe', 'Jane Smith', 'Sam Johnson', 'Emily Davis', 'Emily Davis'],
    'email': ['john.doe@example.com', 'jane.smith@example.com', None, 'emily.davis@example.com', 'emily.davis@example.com'],
    'age': [28, None, 22, 120, 120]
})

# Check for missing values
missing_values = data_with_issues.isnull().sum()
print("Missing Values:\n", missing_values)

# Outlier detection
outliers = data_with_issues[(data_with_issues['age'] > 100) | (data_with_issues['age'] < 0)]
print("Outliers:\n", outliers)

# Basic schema validation
print("Data Types:\n", data_with_issues.dtypes)

# Duplication validation
duplicates = data_with_issues[data_with_issues.duplicated(keep=False)]
if not duplicates.empty:
    print("Duplicate Records:\n", duplicates)
else:
    print("No duplicate records found.")

Data Preparation

— — — — — — — — — — — -

This phase transforms validated data for analysis:

• Data Cleaning: Remove duplicates and handle errors.
• Feature Engineering: Create or adjust features for better model performance.
• Normalization and Scaling: Adjust data for better convergence.
• Splitting the Data: Create training, validation, and testing datasets.

Python Code Example:

from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
import pandas as pd

# Introducing issues in data
data_with_issues = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 4],  # Added a duplicate for testing
    'name': ['John Doe', 'Jane Smith', 'Sam Johnson', 'Emily Davis', 'Emily Davis'],
    'email': ['john.doe@example.com', 'jane.smith@example.com', None, 'emily.davis@example.com', 'emily.davis@example.com'],
    'age': [28, None, 22, 120, 120]
})

# Checking for duplicates before removal
duplicates = data_with_issues[data_with_issues.duplicated(keep=False)]
if not duplicates.empty:
    print("Duplicate Records Found:\n", duplicates)
else:
    print("No duplicate records found.")

# Cleaning data: Remove duplicates and fill missing values
data_cleaned = data_with_issues.drop_duplicates()
print("\nData after removing duplicates:\n", data_cleaned)

# Filling missing age values with the median
data_cleaned['age'].fillna(data_cleaned['age'].median(), inplace=True)

# Normalize the age feature
scaler = MinMaxScaler()
data_cleaned['age_scaled'] = scaler.fit_transform(data_cleaned[['age']])

# Splitting data into train and test sets
train, test = train_test_split(data_cleaned, test_size=0.2, random_state=42)

print("\nTraining Data:")
print(train)
print("\nTesting Data:")
print(test)

This process is very similar to the ETL process of many companies, let’s discuss it:

ETL:

— — —

The ETL (Extract, Transform, Load) process is a crucial component in data warehousing and data integration, enabling organizations to consolidate data from various sources into a single repository for analysis and reporting.

The Data extraction process and preparation process are similar to the Extract (E) and Transform (T) processes of the ETL process!

Since we already talked about data extraction and the data preparation process, let’s talk about storing such data as well.

Data Lake:

— — — — — — —

Data Lake stores raw, unprocessed data in various formats (structured, semi-structured, unstructured) and uses schema-on-read, making it flexible for big data, AI, and machine learning applications.

Examples: Amazon S3 Data Lake, Azure Data Lake Storage (ADLS), Google Cloud Storage Data Lake, Snowflake on AWS/Azure/GCP

Data Warehouse:

— — — — — — — — — — — —

Data Warehouse stores structured, processed data optimized for querying, reporting, and analysis, often using predefined schemas (schema-on-write). It’s ideal for business intelligence.

Examples: Amazon Redshift, Google BigQuery, Azure Synapse Analytics, Snowflake, Greenplum, Apache Hive, Vertica

Hope this knowledge will be helpful starting with MLOps! Stay tuned for what’s next!

Let’s go straight discussion of what to do before the Interview. What to do during the interview? and what to do after the interview :

First, let’s discuss what you should do before the interview:

🔍 1. Research the Company & Industry

• Understand the company’s mission, values, and recent developments.
• Stay updated on industry news, company growth, sales figures, and future plans.
• Check for recent achievements, product launches, or leadership changes.

👤 2. Research the Interviewer & Interview Type

• Find out who will be interviewing you — ask the HR manager if needed.
• Look up the interviewer on LinkedIn to identify mutual connections or shared interests.
• Understand the interview format (technical, HR, panel, etc.).

📄 3. Know Your Resume Inside Out

• Be ready to discuss every detail mentioned on your resume.
• Prepare to elaborate on your experiences, achievements, and skills confidently.

🏃 4. Plan Logistical Details

• Prepare your interview outfit a day before — ensure it’s clean and appropriate.
• Plan your route to the interview location in advance.
• Aim to arrive at least 10–15 minutes early to settle and mentally prepare.

💡 5. Prepare Interview Materials

• Bring multiple copies of your resume.
• Have your portfolio, certifications, or any required documents ready.
• Prepare thoughtful questions to ask the interviewer about the role, team, or company.

🧘 6. Stay Calm and Confident

• Take deep breaths to relax before the interview.
• Visualize success and maintain a positive, confident demeanor.

Now, let’s discuss what to do during the interview:

🎯 1. Make a Strong First Impression

• Greet confidently with a firm handshake, smile, and good eye contact.
• Use polite language and maintain positive body language throughout.
• Introduce yourself clearly and be enthusiastic about the opportunity.

🗣️ 2. Communicate Effectively

• Listen carefully to the questions being asked.
• Answer concisely and stay on topic.
• Use the STAR method (Situation, Task, Action, Result) to structure your answers for behavioral questions.

💼 3. Showcase Your Skills and Experience

• Highlight your relevant achievements and skills.
• Connect your past experiences to the requirements of the role.
• Mention any relevant projects, leadership experiences, or technical skills.

🤝 4. Engage with the Interviewer

• Maintain good eye contact and active listening cues (nodding, acknowledging).
• Show genuine interest in the role and company.
• Be open and honest about your skills and experiences.

❓ 5. Ask Thoughtful Questions

Prepare some insightful questions to ask the interviewer, such as:

• “Can you describe the team I’ll be working with?”
• “What are the immediate challenges for this role?”
• “How is performance typically measured here?”

😌 6. Stay Calm and Professional

• If you don’t know an answer, stay calm — it’s okay to take a moment to think.
• Be honest if you’re unsure but show a willingness to learn.
• Avoid negative comments about previous employers or roles.

🔚 7. End on a Positive Note

• Thank the interviewer for their time.
• Express enthusiasm for the opportunity and mention that you’re looking forward to hearing back.
• Ask about the next steps in the process.

Now, let’s discuss what to do after interview :

📝 1. Reflect and Evaluate

• Review your performance: Write down what went well and areas where you struggled.
• Identify any mistakes: Reflect on questions you could have answered better.
• Track the experience: Keep a journal for future reference and improvement.

📩 2. Follow Up with a Thank You Note

• Send a personalized ‘Thank You’ email within 24 hours of the interview.
• If the interview was in person, consider sending a handwritten note for a personal touch.
• In your message, include:A thank you for their time.A brief mention of something specific you discussed.A reaffirmation of your interest in the role.

🔄 3. Request Feedback

• Politely reach out to the recruiter or interviewer for feedback.
• Ask about areas where you could improve, even if you don’t get the job.
• This will help you grow and prepare better for future opportunities.

🎯 4. Plan Your Next Steps

• Stay proactive and continue applying for other roles.
• Have backup interviews lined up, as not every interview will lead to an offer.
• Keep refining your resume and interview skills based on the feedback received.

📅 5. Follow Up on Application Status

• If you haven’t heard back within the expected time frame, send a polite follow-up email to check on the status of your application.

📊 6. Keep Networking

• Stay connected with the interviewer on LinkedIn (if appropriate).
• Engage with company content or updates to keep yourself visible.

Keep all the points in mind during your next interview 👍

If you found this article useful, repost it ♼ and like so that it will reach to others who need to read this article.

Follow Sandip Das , so that you never miss a single post / article.

When we have a basic application ready, we host that in a single server, but as the user base grows and the application matures more, there is a need to add more servers, and not just that we have to do the load balancing as well.

So, what is this load balancing?

Load balancing is a critical component in modern computing environments, ensuring that workloads are distributed efficiently across multiple servers or resources.

Importance of Load Balancing

1. Improved Performance: By distributing requests evenly across multiple servers, load balancers help to optimize resource use, reduce response times, and improve overall application performance.
2. High Availability: Load balancers can detect server failures and reroute traffic to healthy servers, ensuring that applications remain available even in the event of hardware or software failures.
3. Scalability: As demand increases, load balancers allow for the seamless addition of new servers to handle the increased load without disrupting service.
4. Security: Load balancers can provide an additional layer of security by hiding the internal structure of the network and protecting against certain types of attacks.

Load Balancing Algorithms

There are several algorithms used for load balancing, each with its own advantages and use cases. Here are some of the most common ones:

1. Round Robin

This is one of the simplest load balancing algorithms. It distributes requests sequentially across the available servers. Once the last server is reached, it starts again from the first server. This method is effective for servers with similar capabilities.

Example:

• Request 1 → Server A
• Request 2 → Server B
• Request 3 → Server C
• Request 4 → Server A (restarts cycle)

2. Least Connections

This algorithm directs traffic to the server with the fewest active connections. It is particularly useful in environments where servers have varying capacities and workloads, as it helps to ensure that no single server is overwhelmed.

Example:

• Server A: 5 active connections
• Server B: 2 active connections
• Server C: 8 active connections
• A new request will be directed to Server B as it has the least connections.

3. IP Hash

In this method, the load balancer uses a hash of the client’s IP address to determine which server will handle the request. This ensures that a client is consistently directed to the same server, which can be beneficial for session persistence.

Example:

• Client IP: 192.168.1.10 → Hash Function → Server B
• Client IP: 192.168.1.11 → Hash Function → Server A
• The same IP address will always be mapped to the same server unless the server goes down.

4. Weighted Round Robin

Similar to the Round Robin method, but with weights assigned to each server based on their capacity. Servers with higher weights receive more requests than those with lower weights, allowing for more efficient resource utilization.

• Server A (weight 3): Gets 3 requests
• Server B (weight 2): Gets 2 requests
• Server C (weight 1): Gets 1 request
• The cycle then repeats.

5. Random

As the name suggests, this algorithm randomly selects a server to handle each request. While simple, it may not always lead to optimal resource utilization, especially in environments with servers of varying capabilities.

Example:

• Request 1 → Server B
• Request 2 → Server A
• Request 3 → Server C
• Request 4 → Server A (random selection continues)

6. Least Response Time

This algorithm directs traffic to the server that has the lowest response time. It is particularly useful in scenarios where response time is critical, as it helps to ensure that users receive the fastest possible service.

Example:

• Server A: Response Time 50ms
• Server B: Response Time 30ms
• Server C: Response Time 20ms
• A new request will be directed to Server C as it has the lowest response time.

Here’s a custom logic in Python if you would like to understand in much more hands-on way:

import random
import hashlib

class LoadBalancer:
    def __init__(self, servers):
        self.servers = servers
        self.index = 0
        self.connections = {server: 0 for server in servers}
        self.weights = {server: 1 for server in servers}  # Default weight is 1
        self.server_response_times = {server: random.uniform(0.1, 1.0) for server in servers}

    def round_robin(self):
        server = self.servers[self.index]
        self.index = (self.index + 1) % len(self.servers)
        return server

    def least_connections(self):
        server = min(self.connections, key=self.connections.get)
        self.connections[server] += 1
        return server
    
    def ip_hash(self, client_ip):
        hash_value = int(hashlib.md5(client_ip.encode()).hexdigest(), 16)
        server_index = hash_value % len(self.servers)
        return self.servers[server_index]
    
    def weighted_round_robin(self):
        server = max(self.weights, key=self.weights.get)
        self.weights[server] -= 1  # Reduce weight after selecting
        if all(weight == 0 for weight in self.weights.values()):
            self.weights = {server: 1 for server in self.servers}  # Reset weights
        return server
    
    def random_selection(self):
        return random.choice(self.servers)
    
    def least_response_time(self):
        server = min(self.server_response_times, key=self.server_response_times.get)
        return server

# Example usage
servers = ["Server1", "Server2", "Server3"]
lb = LoadBalancer(servers)

print("Round Robin:", lb.round_robin())
print("Least Connections:", lb.least_connections())
print("IP Hash:", lb.ip_hash("192.168.1.1"))
print("Weighted Round Robin:", lb.weighted_round_robin())
print("Random Selection:", lb.random_selection())
print("Least Response Time:", lb.least_response_time())

Conclusion

Load balancers play a vital role in ensuring the reliability and performance of applications and services in today’s digital landscape. By understanding the various load balancing algorithms available, organizations can choose the most suitable method for their specific needs, ultimately leading to improved user experiences and efficient resource management.

if you found this useful, like this article and repost with other’s so they too get a better understanding of Load balancer and follow Sandip Das for more.

Client-server communication is a fundamental concept enabling interaction between clients and servers, but let me clear it a bit more:

Client-server communication is a model where a client (e.g., browser, mobile app) requests services from a server (e.g., web server, database), which processes the request and responds over a network using protocols like HTTP, WebSockets, or gRPC. It enables distributed computing, ensuring efficient resource sharing and data exchange.

Understanding different communication methods is essential for designing efficient and scalable network applications.

Below are the key types of client-server communication, their characteristics, advantages, use cases, and coding examples.

1. Synchronous Communication

Synchronous communication occurs in real-time, requiring both client and server to be available simultaneously. It is characterized by immediate responses and is crucial for applications demanding timely data exchange.

Advantages:

• Real-time interaction
• Immediate feedback
• Ideal for time-sensitive applications

Use Cases:

• Video conferencing
• Online multiplayer gaming
• Stock market trading platforms

Example:

• HTTP (Hypertext Transfer Protocol)
• WebSockets
• gRPC (Google Remote Procedure Call)

Code Example: (Python — Synchronous HTTP Request):

import requests
response = requests.get('https://api.example.com/data')
print(response.text)

2. Asynchronous Communication

Asynchronous communication allows clients and servers to operate independently. The client can send a request without waiting for an immediate response, improving efficiency and scalability.

Advantages:

• Enhanced performance and scalability
• Reduced wait times for clients
• Flexibility in request processing

Use Cases:

• Background task processing (e.g., order processing systems)
• Push notifications in mobile apps
• Asynchronous event-driven architectures

Example:

• RabbitMQ
• Apache Kafka
• AWS SQS (Simple Queue Service)
• Programming Async scanarios

Code Example: Python — Asynchronous HTTP Request

import aiohttp
import asyncio

async def fetch():
    async with aiohttp.ClientSession() as session:
        async with session.get('https://api.example.com/data') as response:
            print(await response.text())

asyncio.run(fetch())

3. Request-Response Communication

In this model, the client sends a request, and the server processes it before returning a response. It is commonly used in web applications and API interactions.

Advantages:

• Simple and easy to implement
• Well-supported across platforms
• Predictable and structured

Use Cases:

• RESTful API interactions
• CRUD operations in web applications
• Database queries and transactions

Example:

• RESTful APIs
• GraphQL
• SOAP (Simple Object Access Protocol)

Code Example: Python — Flask API Request-Response

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/data', methods=['GET'])
def get_data():
    return jsonify({"message": "Hello, World!"})

if __name__ == '__main__':
    app.run(debug=True)

4. Publish-Subscribe Communication (Pub-Sub)

The publish-subscribe model allows clients to subscribe to topics while servers publish messages to those topics. It enables decoupled and scalable communication.

Advantages:

• Scalable and flexible
• Decoupled architecture
• Efficient broadcasting to multiple clients

Use Cases:

• Real-time news feeds (e.g., stock market alerts)
• Social media notifications (e.g., Facebook updates)
• IoT sensor data distribution

Example:

• MQTT (Message Queuing Telemetry Transport)
• Apache Kafka
• Redis Pub/Sub

Code Example: Python — MQTT Publish-Subscribe

import paho.mqtt.client as mqtt

def on_message(client, userdata, message):
    print(f"Received message: {message.payload.decode()}")

client = mqtt.Client()
client.on_message = on_message
client.connect("mqtt.example.com")
client.subscribe("/topic/test")
client.loop_start()

5. Peer-to-Peer (P2P) Communication

In P2P communication, clients can act as both servers and clients, allowing direct resource sharing without a centralized server.

Advantages:

• Reduced server load
• Increased fault tolerance
• Enhanced resource sharing

Use Cases:

• File sharing networks (e.g., BitTorrent)
• Decentralized blockchain networks (e.g., Bitcoin, Ethereum)
• Distributed computing systems (e.g., SETI@home)

Example:

• BitTorrent
• IPFS (InterPlanetary File System)
• WebRTC

Code Example: Python — P2P Socket Communication

import socket

# Server
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("0.0.0.0", 5000))
server.listen(1)
conn, addr = server.accept()
print("Connected by", addr)
conn.sendall(b'Hello, Peer!')
conn.close()

# Client
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("127.0.0.1", 5000))
data = client.recv(1024)
print(f"Received {data.decode()}")
client.close()

Conclusion

Choosing the right client-server communication method is crucial for building efficient and scalable network applications. Each method offers unique advantages suited for specific use cases. By leveraging these communication models effectively, developers can create robust, responsive, and scalable systems that meet user demands

Found it useful?

If Yes repost this article with your network and follow Sandip Das for more!

There’s a lot of misunderstanding (or no understanding at all) of AI & ML , before jumping deep into the world of MLOps, let’s clear those concepts RIGHT NOW!

First, let’s understand what is AI?

Artificial Intelligence (AI) is the simulation of human intelligence in machines to perform tasks like learning, reasoning, and problem-solving.

What is ML?

Machine Learning (ML) is a subset of AI that enables systems to learn from data and make predictions or decisions without explicit programming.

What is the ML Model?

An ML (Machine Learning) model is a mathematical representation trained on data using an algorithm to recognize patterns, make predictions, or decisions without explicit programming.

It is the output of the training process, enabling a system to infer outcomes from new, unseen data.

ML Model Training Methods:

• Supervised Learning: Learns a mapping from input data to labeled outputs for prediction tasks (e.g., regression, classification).
• Unsupervised Learning: Identifies patterns, structures, or clusters in unlabeled data (e.g., clustering, dimensionality reduction).
• Reinforcement Learning: Trains agents to make sequential decisions by maximizing rewards in an environment (e.g., Q-learning, policy-based methods).
• Semi-Supervised Learning: Combines labeled and unlabeled data to improve learning accuracy, especially when labeled data is scarce.
• Deep Learning (DL): Uses neural networks with multiple layers to learn complex features from data, enabling tasks like image recognition and natural language understanding.
• Online Learning: Continuously updates the model as new data arrives, ideal for dynamic environments.
• Transfer Learning: Adapts knowledge from a previously trained model to a new, but related, task or domain.
• Ensemble Learning: Combines multiple models to improve overall prediction accuracy, often using techniques like bagging and boosting.

Foundation Models (FMs):

Foundation Models (FMs) are large-scale AI models trained on vast amounts of diverse data, making them general-purpose and adaptable for a wide range of tasks, such as natural language processing (NLP), image generation, and coding. These models serve as the “foundation” for various AI applications, allowing fine-tuning for specific use cases.

Key Characteristics of Foundation Models

• Pretrained on Massive Datasets Trained on billions of parameters using text, code, images, and videos.Learn broad patterns in data, making them adaptable.
• General-Purpose Capabilities Can perform multiple tasks (e.g., text summarization, translation, image generation) without retraining. Examples: GPT-4 (text), Stable Diffusion (images), Code Llama (coding).
• Fine-Tuning for Custom Use Cases Can be customized for domain-specific applications. Example: A healthcare chatbot trained on medical literature.
• Scalability & API Access Deployed in cloud environments like AWS, Azure, and Google Cloud.Available via APIs for easy integration.

Famous ML Models

• DeepSeek R1 — A high-performance Chinese AI model optimized for reasoning and language tasks.
• Sonet — A small but efficient LLM designed for resource-constrained environments.
• Meta’s LLaMA — A family of open-weight AI models optimized for research and deployment.
• OpenAI’s GPT — A state-of-the-art generative AI model powering ChatGPT and other applications.
• Google’s Gemini — A multimodal AI model integrating text, images, and reasoning capabilities.
• BERT (Bidirectional Encoder Representations from Transformers) — A pre-trained NLP model by Google designed for understanding context in language tasks, widely used for search ranking, Q&A, and text classification.
• Mistral AI — A state-of-the-art open-weight model known for efficiency and performance.
• Claude (Anthropic) — A conversational AI model focused on safety, accuracy, and reliability
• Mosaic MPT — A scalable LLM optimized for low-latency inference.

While talking about Foundation models or any famous opensource models , let’s talk about Hugging face, using which we can download and do a lot more:

Hugging Face

Hugging Face is the leading open-source AI hub, providing pretrained AI models, datasets, and developer tools for NLP, computer vision, and beyond. It acts as a collaborative AI platform where researchers and developers share and fine-tune models.

Key Features:

• Hosts thousands of open-source AI models (GPT, LLaMA, DeepSeek, Mistral, etc.).
• Provides Transformers library, a widely used framework for NLP models.
• Allows easy fine-tuning and deployment of models via Inference API.
• Supports AI communities, enabling research collaboration and development.
• Hugging Face is central to the AI ecosystem, powering AI applications across research, startups, and enterprise deployments.

Now, before we talk about Generative AI , we should first learn about LLM

LLM

LLMs stands for Large Language Models!

It’s an advanced deep learning models trained on vast amounts of text data to understand, generate, and process human language. These models, based on architectures like Transformer (e.g., GPT, BERT, LLaMA)

How LLMs Work?

• Training on Massive Datasets — LLMs are trained on billions to trillions of words and diverse datasets (e.g., books, websites, articles)
• Tokenization — Text is broken into smaller units e.g. words or subwords (called “tokens”) for processing.
• Self-Attention Mechanism — LLMs weigh the importance of different words in a sentence to understand context.
• Contains billions of parameters (e.g., GPT-3 has 175 billion parameters).

LLMs Limitations:

• Hallucinations: May generate plausible-sounding but incorrect/fabricated information.
• Bias: Reflects biases present in training data (e.g., cultural, gender, or political biases).
• Computational Cost: Requires massive computational power for training and inference.
• Ethics: Risks of misuse (e.g., deepfakes, spam, misinformation).
• Context Window: Limited memory of earlier text in long conversations (though newer models have improved this).

Now, let’s learn about Generative AI:

Generative AI

Generative AI refers to artificial intelligence models that can generate new content (text, images, code, music, video, etc.) based on learned patterns from large datasets. Unlike traditional AI, which mainly classifies or predicts, Generative AI creates new outputs. e.g. ChatGPT, Claude, Gemini, Github co-pilot etc

How Generative AI Works?

• Pre-training on Large Datasets — AI models are trained on massive datasets (text, images, code, etc.).
• Transformer-Based Architectures — Uses deep learning models like GPT (for text), Stable Diffusion (for images), or DALL·E.
• Prompt-Based Generation — Users input a text prompt, and the AI generates relevant content.
• Fine-tuning for Specific Tasks — The models can be adapted for specific domains (e.g., DevOps automation, cybersecurity).

Key Models in Generative AI:

• LLMs (Large Language Models) — DeepSeek v3 & R1, GPT, LLaMA, Falcon (for text & code generation)
• Image Generators — DALL·E, MidJourney, Stable Diffusion
• Audio & Music Generators — OpenAI’s Jukebox, Google’s MusicLM
• Video Generators — RunwayML, Sora

While talking about Gen AI, we should learn about RAG:

Retrieval-Augmented Generation (RAG):

Retrieval-Augmented Generation (RAG) is an AI technique that enhances the responses of large language models (LLMs) by retrieving relevant external data before generating an answer. It helps LLMs overcome knowledge cutoffs, hallucinations, and limited context windows.

How RAG Works?

• User Query → The model receives a question or prompt.
• Retrieval Step → It searches external data sources (databases, documents, APIs, etc.) for relevant information.
• Augmentation Step → The retrieved data is fed back into the LLM to improve its understanding.
• Generation Step → The model generates an accurate, context-aware response.

This approach combines retrieval-based search with generative AI, leading to more accurate, up-to-date, and explainable results.

While talking about GenAI , how can we miss Amazon BedRock:

Amazon BedRock

Amazon Bedrock is a fully managed service by AWS that allows users to build and scale generative AI applications using foundation models (FMs) from various AI model providers. It enables developers to integrate these models into their applications without managing the underlying infrastructure.

Why to use Amazon Bedrock?

Access to Multiple Foundation Models:

• Supports models from Amazon, Anthropic, Cohere, Meta, Stability AI, Mistral AI, and others.
• Examples: Claude (Anthropic), Llama (Meta), Command R (Cohere), Stable Diffusion (Stability AI).

Customization with Fine-tuning & RAG:

• Fine-tune foundation models using your own proprietary data.
• Use Retrieval Augmented Generation (RAG) to improve model responses with enterprise data.

Seamless Integration with AWS Services

• Amazon S3 (for data storage).
• AWS Lambda (for serverless execution).
• Amazon SageMaker (for ML/AI workflows).
• Amazon Kendra (for AI-powered search).
• Amazon DynamoDB / RDS (for structured data storage)

Hope this will help understand AI & ML basics, next, we will cover Data Extraction, Vadilation & Preparation for MLOps

Follow Sandip Das for more!