DEV Community: Tejas Shinkar

From System Engineer to Cloud & DevOps Engineer: Understanding the Big Picture

Tejas Shinkar — Mon, 01 Jun 2026 14:00:47 +0000

Introduction

As I begin my Cloud and DevOps learning journey, I realized that jumping directly into tools like Docker, Kubernetes, Jenkins, or AWS services can be overwhelming without first understanding the bigger picture.

This lecture wasn't about learning commands or configurations. Instead, it focused on connecting the dots between traditional IT infrastructure, cloud computing, Linux, virtualization, and DevOps. The goal was to understand how the modern software delivery ecosystem evolved and why Cloud and DevOps became essential.

The Traditional System Engineer

Before cloud platforms became mainstream, companies managed their own infrastructure.

A System Engineer was responsible for:

Managing physical servers
Installing operating systems
Configuring networking
Monitoring hardware
Managing storage and backups
Troubleshooting system issues

When a company needed more resources, new hardware had to be purchased, installed, configured, and maintained manually.

This approach worked, but it introduced several challenges:

High upfront costs
Long provisioning times
Difficult scalability
Heavy operational overhead

As applications and user bases grew, organizations needed a more flexible approach.

Understanding Servers

One important realization from this lecture was that a server is not a special type of machine.

A server is simply a computer that provides services to other computers.

Examples include:

Web Servers
Database Servers
File Servers
Mail Servers

Whenever we open a website, send an email, or watch a video online, a server somewhere is responding to our request.

This simple concept forms the foundation of everything that follows.

Hosting and Deployment

Applications cannot serve users from a developer's laptop.

They must be hosted somewhere.

Hosting refers to providing the infrastructure where applications run.

Deployment refers to moving an application from a development environment into an environment where users can access it.

A simple flow looks like:

Developer → Build Application → Deploy to Server → Users Access Application

As organizations grew, deployment became increasingly complex, leading to the need for automation and better operational practices.

The Rise of Cloud Computing

Instead of buying and maintaining physical servers, organizations started renting computing resources from cloud providers.

This is where cloud computing enters the picture.

Cloud computing provides:

Compute resources
Storage
Networking
Databases
Security services

on demand through the internet.

Rather than spending weeks setting up infrastructure, organizations can provision resources within minutes.

Major cloud providers include:

Amazon Web Services (AWS)
Microsoft Azure
Google Cloud Platform (GCP)

The cloud transformed infrastructure from a physical asset into a service.

Datacenters: The Foundation Behind the Cloud

Although cloud services appear virtual, they still run on physical hardware.

That hardware exists inside massive datacenters.

A datacenter contains:

Thousands of servers
Networking equipment
Storage systems
Cooling infrastructure
Power backup systems

Cloud providers build and manage these datacenters around the world.

When we launch an AWS EC2 instance, we are actually renting a small portion of a physical server located inside one of these datacenters.

Virtualization: The Technology That Changed Everything

One physical server often has more resources than a single application requires.

Virtualization allows multiple virtual machines to share the same hardware efficiently.

A virtualization layer called a Hypervisor sits between the hardware and virtual machines.

Examples:

VMware ESXi
Hyper-V
VirtualBox

Through virtualization:

One Physical Server
→ Multiple Virtual Machines
→ Multiple Independent Operating Systems

This innovation dramatically improved resource utilization and became one of the core technologies behind cloud computing.

VirtualBox, ISO Images, and Learning Environments

To practice Linux and cloud concepts locally, we use tools like VirtualBox.

VirtualBox allows us to run a virtual machine inside our existing operating system.

The operating system is typically installed using an ISO image, which contains all installation files required to create a new operating system environment.

This creates a safe sandbox where we can learn Linux administration without affecting our primary machine.

Linux: The Backbone of Modern Infrastructure

One of the strongest themes throughout the lecture was the importance of Linux.

Most cloud servers today run Linux.

Reasons include:

Stability
Security
Performance
Open-source ecosystem
Automation friendliness

Linux powers:

AWS workloads
Kubernetes clusters
Containers
Modern web infrastructure

Understanding Linux is therefore one of the most important skills for aspiring Cloud and DevOps Engineers.

Linux, Operating Systems, and Kernels

A common misconception is that Linux itself is an operating system.

Technically, Linux is a kernel.

The kernel is the core software component responsible for:

Process management
Memory management
Device communication
CPU scheduling

What we commonly call a Linux operating system is actually:

Linux Kernel + User Space Tools + Utilities

Examples include:

Ubuntu
Red Hat Enterprise Linux (RHEL)
Rocky Linux
AlmaLinux

Understanding this distinction is important for interviews and system-level discussions.

What Happens When a System Boots?

The lecture also explored the startup sequence of a computer.

A simplified boot process looks like:

System powers on
BIOS/UEFI initializes hardware
Bootloader starts
Kernel loads into RAM
System services start
User login becomes available

This process demonstrates the central role played by the kernel in operating system functionality.

Why Red Hat Is Widely Used in Enterprises

While many Linux distributions exist, Red Hat Enterprise Linux remains one of the most widely adopted enterprise operating systems.

Organizations choose Red Hat because of:

Long-term support
Enterprise-grade stability
Security updates
Vendor support
Industry certifications

Many production environments use Red Hat directly or compatible distributions such as Rocky Linux and AlmaLinux.

The Problem Before DevOps

Historically, development and operations teams worked separately.

Developers focused on writing code.

Operations teams focused on infrastructure and deployments.

This separation often caused issues:

Slow releases
Communication gaps
Manual deployment errors
Increased downtime

A common situation was:

"It works on my machine."

but not on the production server.

The industry needed a better approach.

Enter DevOps

DevOps emerged as a culture and set of practices designed to bridge the gap between development and operations.

Its goals include:

Faster software delivery
Better collaboration
Automation
Improved reliability
Continuous improvement

Rather than treating development and operations as separate responsibilities, DevOps encourages shared ownership of the software delivery lifecycle.

CI/CD: The Automation Engine of DevOps

One of the key implementations of DevOps is CI/CD.

CI (Continuous Integration):

Automatically builds code
Runs tests
Detects issues early

CD (Continuous Delivery/Deployment):

Automates software releases
Reduces manual effort
Enables faster deployments

A modern workflow often looks like:

Developer
→ Git Repository
→ CI/CD Pipeline
→ Automated Testing
→ Deployment
→ Production

This automation significantly reduces human error and accelerates software delivery.

AWS EC2: Where Cloud Meets Infrastructure

An EC2 instance can be thought of as a virtual server running inside AWS.

Instead of purchasing hardware, organizations can launch servers within minutes.

These instances can host:

Websites
APIs
Databases
Enterprise applications

EC2 represents a practical example of how cloud computing abstracts infrastructure management while still providing full control over operating systems and applications.

Connecting All the Dots

The most valuable takeaway from this lecture was understanding how all these concepts relate to one another.

A modern software delivery workflow looks like:

Datacenter
→ Cloud Provider (AWS)
→ Virtualization
→ EC2 Instance
→ Linux Operating System
→ Application Deployment
→ CI/CD Automation
→ DevOps Practices

This progression explains the industry's evolution from traditional system administration to cloud-native and DevOps-driven operations.

Understanding these relationships creates a strong foundation before moving into advanced topics such as Linux administration, AWS services, Infrastructure as Code, Docker, Kubernetes, and CI/CD pipelines.

Conclusion

This lecture was less about learning individual technologies and more about understanding the ecosystem they belong to.

Cloud, Linux, Virtualization, Deployment, CI/CD, and DevOps are not isolated topics. They are interconnected components of a modern infrastructure stack.

Before learning tools, it is important to understand why those tools exist and which problems they solve.

That understanding forms the foundation of becoming a Cloud and DevOps Engineer.

Python Day 2: Conditions, Loops & Functions — The Engine Behind Every AI App

Tejas Shinkar — Wed, 20 May 2026 19:45:20 +0000

Introduction

Variables store data. But conditions, loops, and functions are what make programs think, repeat, and scale.

These concepts power AI agents, automation scripts, backend APIs, chatbots, and workflow systems. Every intelligent application you build will rely on these fundamentals.

🧠 Conditions — Decision Making

Conditions allow programs to make decisions based on logic.

if condition:
# runs if True

elif another_condition:
# runs if first condition was False

else:
# runs if nothing above was True


## ⚡ Truthy & Falsy Values

Python automatically evaluates many non-boolean values as `True` or `False`.

| Falsy Values | Truthy Values       |
| ------------ | ------------------- |
| `None`       | Any non-zero number |
| `0`, `0.0`   | Non-empty string    |
| `""`         | Non-empty list/dict |
| `[]`, `{}`   | `True`              |

id="avop9y"
response = ""

if response:
process(response)


Since the string is empty, the condition evaluates to `False`.

---

# 🔁 Loops — The Foundation of Automation

Loops allow programs to repeat actions automatically.

### `for` Loop

id="7v9xph"
for item in collection:
process(item)


### `while` Loop

id="6egrr4"
while condition:
do_something()
update_condition()


⚠️ Always update the condition to avoid infinite loops.

### 🛑 Loop Control

id="itj7l8"
break # exits loop immediately
continue # skips current iteration


---

# 🧩 Functions — Reusability & Structure

Functions help organize logic into reusable blocks.

id="5g9w1m"
def function_name(parameter, optional=default):
return result


## `return` vs `print`

`print()` only displays output.

id="7r1ux0"
print("Hello")


`return` sends data back to the caller.

id="p5u3gq"
def add(a, b):
return a + b


Returned values can be stored and reused later.

---

# 🤖 Real-World AI Pattern

id="31f4b0"
def detect_intent(query):

query = query.lower()

if "summarize" in query:
    return "summarize"

elif "translate" in query:
    return "translate"

else:
    return "general"

while True:

query = input("You: ").strip()

if query == "quit":
    break

intent = detect_intent(query)

print(f"Intent: {intent}")


This same pattern powers:

* AI assistants
* chatbot systems
* intent classification
* prompt routing
* automation workflows

---

# ❌ Common Beginner Mistakes

### Infinite Loops

id="k91o93"
while True:
pass


### Using `print()` Instead of `return`

id="5wt8te"
def add(a, b):
print(a + b)


### Forgetting `range()` Excludes End Value

id="uvd2vv"
range(1, 5)


Output:

id="fiy6wp"
1 2 3 4




---

# 🎯 Key Takeaways

* Conditions make programs intelligent
* Loops make programs scalable
* Functions make programs maintainable
* `while True` + `break` is a standard interactive pattern
* Prefer `return` over `print`
* Small reusable functions lead to cleaner architecture

---

## 📌 What's Next?

➡️ Lists & Dictionaries
➡️ String Processing
➡️ Error Handling
➡️ Building Real Automation Scripts

---

## 💡 Final Thought

Most modern AI systems look complex on the surface.

Underneath, they are still powered by conditions, loops, functions, and data flow.

Master these fundamentals deeply, and advanced engineering concepts become much easier later.

#Python #AI #Programming #Beginners

Python Day 1: Variables, Data Types & Input/Output for AI Engineers

Tejas Shinkar — Tue, 19 May 2026 06:09:45 +0000

🚀 Python Day 1: Variables, Data Types & I/O — The Foundation of Every AI App

Introduction

Before you build AI agents, LLM pipelines, or automation tools — you write variables.

Every production AI system, at its core, is managing, transforming, and displaying data.

Day 1 is where real engineers are separated from tutorial followers.

🧠 What is a Variable?

A variable is a named reference to an object in memory.

model_name = "claude-sonnet-4-20250514"
temperature = 0.7
is_streaming = True

Python is dynamically typed — variables don't have fixed types. The objects they point to do.

📦 Python's Core Data Types

Type	Example	AI/ML Use Case
`int`	`1000`	max_tokens, batch_size
`float`	`0.7`	temperature, probability
`str`	`"prompt"`	user input, API keys
`bool`	`True`	flags, conditions
`NoneType`	`None`	missing values

⌨️ Input and Output

name = input("Enter name: ").strip()  # always strip input
print(f"Hello, {name}!")              # always use f-strings

⚠️ input() always returns a string. Convert explicitly.

age = int(input("Age: "))       # string → int
price = float(input("Price: ")) # string → float

🔤 String Operations — Essential for AI Apps

prompt = "  Summarize this document  "

prompt.strip()       # remove whitespace
prompt.upper()       # UPPERCASE
prompt.lower()       # lowercase
prompt.title()       # Title Case
prompt.replace("document", "report")
len(prompt)          # character count

⚡ f-Strings — The Modern Standard

user = "Arjun"
tokens = 1000

print(f"User: {user}, Max Tokens: {tokens}")
print(f"Score: {0.9534:.2f}")

✅ Clean
✅ Readable
✅ Industry standard

🤖 Real-World AI App Pattern

# Every LLM app starts like this

user_input = input("Ask AI: ").strip().lower()

system_prompt = (
    f"You are a helpful assistant. "
    f"User asked: {user_input}"
)

temperature = 0.7
max_tokens = 1000

This is the same foundation used in:

AI chatbots
Prompt engineering
LLM wrappers
AI automation workflows
Agent systems

❌ Common Beginner Mistakes

1. Forgetting type conversion

age = input("Age: ")
print(age + 5)   # ❌ Error

2. Using `=` instead of `==`

if age = 18:   # ❌

3. Forgetting `.strip()`

Extra spaces silently break logic.

4. Confusing `None`, `False`, and `0`

They are not the same thing.

5. Using old `%s` formatting

Use f-strings instead.

🎯 Key Takeaways

Variables are references, not containers
Python infers types dynamically
input() always returns strings
Always convert types explicitly
f-strings are the modern standard
Clean snake_case naming looks professional

📌 What's Next?

➡️ Operators & Expressions
➡️ Conditional Logic (if / elif / else)
➡️ Loops — where automation really begins

💡 Final Thought

Every advanced AI system starts with simple fundamentals.

Master the basics deeply, and the complex stuff becomes easier later.

Python #AI #Beginners #Programming

DEV Community: Tejas Shinkar

From System Engineer to Cloud & DevOps Engineer: Understanding the Big Picture

Introduction

The Traditional System Engineer

Understanding Servers

Hosting and Deployment

The Rise of Cloud Computing

Datacenters: The Foundation Behind the Cloud

Virtualization: The Technology That Changed Everything

VirtualBox, ISO Images, and Learning Environments

Linux: The Backbone of Modern Infrastructure

Linux, Operating Systems, and Kernels

What Happens When a System Boots?

Why Red Hat Is Widely Used in Enterprises

The Problem Before DevOps

Enter DevOps

CI/CD: The Automation Engine of DevOps

AWS EC2: Where Cloud Meets Infrastructure

Connecting All the Dots

Conclusion

Python Day 2: Conditions, Loops & Functions — The Engine Behind Every AI App

Introduction

🧠 Conditions — Decision Making

Python Day 1: Variables, Data Types & Input/Output for AI Engineers

🚀 Python Day 1: Variables, Data Types & I/O — The Foundation of Every AI App

Introduction

🧠 What is a Variable?

⌨️ Input and Output

🔤 String Operations — Essential for AI Apps

⚡ f-Strings — The Modern Standard

🤖 Real-World AI App Pattern

❌ Common Beginner Mistakes

1. Forgetting type conversion

2. Using = instead of ==

3. Forgetting .strip()

4. Confusing None, False, and 0

5. Using old %s formatting

🎯 Key Takeaways

📌 What's Next?

💡 Final Thought

Python #AI #Beginners #Programming

2. Using `=` instead of `==`

3. Forgetting `.strip()`

4. Confusing `None`, `False`, and `0`

5. Using old `%s` formatting