When I first decided to shift my career to cloud engineering, I had zero tech background. I didn’t study IT, didn’t know programming, and felt completely lost when terms like Linux, Python, SQL, and GitHub started popping up everywhere. At first, I even questioned whether I could really do this.

But here’s the truth: you don’t need to be a genius to learn cloud engineering. You just need curiosity, consistency, and the right tools to practice hands-on. For me, two resources made all the difference: TechKubo, which offers browser-based playgrounds for Linux, Python, and SQL, and Tutorials Dojo, which provides structured, beginner-friendly courses with practical labs. Together, they gave me the structure, practice, and confidence I needed to start my journey.

In this article, I’m sharing the first skills I focused on: Linux, Python, SQL, and GitHub. I’ll explain why each skill is essential, how I practiced it, and how beginners can replicate my path.

Introduction to Operating Systems: Understanding the Foundation

Before learning Linux, it’s important to understand what an operating system (OS) is and why it’s essential in computing and cloud engineering.

Simply put, an OS is software that manages your computer’s hardware and allows you to interact with it through applications. Think of it as a manager or conductor: it coordinates all the parts of your computer to work together smoothly.

For example:

• When you open a browser, the OS decides how much memory and CPU time to give it.

• When you save a file, the OS manages where it is stored and how it can be accessed.

• When multiple programs are running, the OS ensures they don’t interfere with each other.

Key Roles of an Operating System

1. Resource Management – The OS manages hardware resources like CPU, memory, storage, and network connections.

2. Process Management – It decides which programs run and when, making sure everything operates efficiently.

3. File Management – Organizes files on storage devices, controls permissions, and keeps data safe.

4. User Interface – Provides a way for users to interact with the computer (graphical UI or command line).

5. Security – Protects the system from unauthorized access and manages permissions.

Operating systems are designed for different purposes:

Image Generated by AI

Why Understanding an OS Matters

Understanding the basics of an operating system provides several key benefits. First, it gives you control over your environment, helping you understand how applications communicate with and use the computer’s hardware. Second, it enhances your problem-solving skills, enabling you to troubleshoot issues related to memory, running processes, or file permissions more effectively. Finally, it builds a strong foundation for advanced skills, as concepts like networking, virtualization, and cloud computing tools all rely heavily on OS knowledge.

Part 1 — Learning Linux: The Foundation of Cloud Systems

The journey into cloud engineering began with Linux, and at first, it was honestly intimidating. Unlike Windows or macOS, Linux relies heavily on a command-line interface (CLI), where every action—from navigating directories to creating files—requires typing commands instead of clicking buttons. Simple tasks that are straightforward on a graphical interface initially felt confusing and overwhelming.

But I quickly realized why learning Linux is so essential: it is the backbone of cloud computing. Nearly every server running in the cloud uses Linux because of its stability, security, and flexibility. Understanding Linux gives you direct control over the environment that powers modern applications and services, which is a crucial skill for any cloud engineer.

Why TechKubo Makes Learning Linux Beginner-Friendly

Linux Playground (Retrieved from Techkubo.com)

If you’re new to Linux, I highly recommend starting with TechKubo’s Linux Playground. It’s a browser-based, interactive environment where you can practice Linux commands without installing anything on your computer. Here’s why I found it incredibly useful:

• Safe experimentation: You can try commands and make mistakes without worrying about breaking your system.

• Hands-on learning: Typing commands yourself helps you remember them far better than reading or watching videos.

• Immediate feedback: You see results in real-time, which makes learning interactive and engaging.

In TechKubo, I focused on core Linux skills first:

1. Navigating the File System

Understanding the Linux file system is essential because it’s different from Windows or macOS. Some key commands:

• pwd → shows your current directory

• ls → lists files and folders

• cd directory_name → changes your current directory

Tip: Think of your directories like folders in a filing cabinet. You need to know where everything is located to work efficiently.

2. Managing Files and Folders

Once you can navigate, it’s important to create, move, and delete files:

• touch filename → creates a new empty file

• mkdir foldername → creates a new folder

• rm filename → deletes a file

• rmdir foldername → deletes an empty folder

• mv source destination → moves or renames files

Practice: Try creating a folder called cloud_practice and several files inside it. Move the files around and delete them. This builds muscle memory for essential file operations.

3. Editing Files

Linux allows you to edit files directly in the terminal:

• nano filename → opens a simple text editor

• cat filename → displays file content

• less filename → scroll through files easily

Tip: Nano is beginner-friendly. Start by writing short text, saving, and experimenting with navigation.

4. Understanding File Permissions

Permissions control who can read, write, or execute files:

• chmod → changes permissions

• chown → changes file ownership

• ls -l → shows file permissions

Tip: File permissions are a fundamental concept in Linux and critical for cloud security. Experiment by changing permissions and observing the results.

5. Managing Processes

Linux allows you to monitor and manage running programs:

• ps → lists running processes

• top → shows real-time CPU and memory usage

• kill process_id → stops a process

Understanding processes helps you identify issues and optimize server performance—a skill cloud engineers use constantly.

Why I Recommend Tutorials Dojo for Guided Learning

Retrieved from TutorialsDojo.com

While TechKubo allowed me to experiment freely, I also followed Tutorials Dojo’s Linux beginner course, which provides structured lessons with exercises. Here’s what I gained from it:

• Step-by-step guidance on commands, file management, and system monitoring

• Hands-on exercises that simulate real-world server scenarios

• Understanding logs, processes, and permissions in a practical context

• Confidence to explore more advanced topics, like networking and automation

Combining TechKubo’s free playground with Tutorials Dojo’s structured lessons helped me connect theory with practice, making Linux feel less intimidating and more like a tool I could master.

Practical Tips for Beginners

1. Practice consistently: Even 15–30 minutes per day builds familiarity.

2. Experiment boldly: Try combining commands, using flags, or editing files—you’ll learn faster by testing.

3. Keep notes: Write down commands, their purpose, and examples. Your notes become a reference you’ll revisit often.

4. Break tasks into steps: Focus on one concept at a time before moving to advanced commands.

5. Embrace errors: Mistakes are opportunities to understand Linux better

   ---

Part 2 — Learning Python: The Language of Automation and Cloud

After getting comfortable with Linux, I moved on to Python, a language that many cloud engineers and developers swear by. At first, it felt intimidating—coding seemed like a completely different world filled with symbols, numbers, and unfamiliar words. But I soon realized that Python is designed to be simple and human-readable, which makes it one of the most beginner-friendly programming languages out there.

Python is everywhere in cloud computing. Whether it’s automating repetitive tasks, managing servers, or interacting with cloud platforms like AWS, Azure, or Google Cloud, Python is often the tool that makes things easier. Unlike other languages that have complex syntax, Python allows you to focus on solving problems rather than memorizing rules. This is why I chose to start with Python as my first programming language

Understanding Python Concepts

When I first started, the idea of “variables” made sense once I thought of them as containers for storing information. You can store a name, a number, or a true/false value in a variable, and use it later in your program. For example, storing a user’s name or tracking a count of actions is as simple as giving the information a label.

Next, I discovered that Python isn’t just about storing information—it’s about making decisions and automating tasks. Using conditionals like if and else, Python can evaluate situations and decide what to do next. For instance, it can check whether a user is logged in, or whether a number is higher than a threshold, and respond accordingly. This decision-making capability is what allows Python scripts to adapt to different situations, much like a human would.

Loops were another eye-opener. I realized that tasks I would normally repeat over and over could be automated in just a few lines of code. Python’s for and while loops allow a program to repeat actions, like processing multiple files or performing calculations on a list of numbers, without needing me to write the same instructions dozens of times. This concept alone demonstrated the power of programming to save time and reduce errors, a crucial skill for anyone working in cloud operations or automation.

Then came functions—a concept that initially felt abstract but quickly became one of Python’s most powerful features. Functions let you group a set of instructions under one name, so you can reuse them whenever needed. For example, instead of writing the same greeting message multiple times, you can create a “greet” function and call it whenever necessary. This not only makes code shorter but also easier to read and maintain.

Python also made me appreciate the importance of organizing data efficiently. Lists, dictionaries, and other collections allow you to manage multiple pieces of information at once. For example, a list can store all the user names on a platform, while a dictionary can pair each user with their profile details. Once I understood these structures, I realized how Python could handle large sets of data with ease, which is essential in cloud computing.

Hands-On Practice with TechKubo

Python Playground (Retrieved from Techkubo.com)

For beginners like me, TechKubo’s Python Playground was a game-changer. It’s a browser-based environment where you can experiment with Python code safely, without installing anything on your computer. I found it incredibly useful because:

• You can try out Python commands and see results instantly.

• Mistakes don’t break anything, so experimenting feels safe.

• It encourages learning by doing, which makes abstract concepts easier to understand.

In TechKubo, I started with core Python concepts:

• Variables and data types: Storing text, numbers, and True/False values.

• Input and output: Making programs interactive by asking users for information.

• Conditionals: Letting programs make decisions using if and else.

• Loops: Repeating tasks efficiently using for and while.

• Functions: Grouping instructions to make code reusable and organized.

• Data structures: Using lists and dictionaries to manage multiple pieces of information.

Experimenting in TechKubo made these concepts tangible. For example, I could write a small program to greet users, loop through a list of numbers, or store information about multiple users—all in the same browser window. The immediate feedback helped me understand cause and effect in programming, which accelerated my learning.

Why Python is Beginner-Friendly

Python reads almost like English, which makes it easy to grasp for beginners. Commands like print, input, and for are intuitive, and the indentation-based structure keeps code organized naturally. This simplicity allows beginners to focus on problem-solving and logical thinking—skills that are more important than memorizing syntax.

Python also encourages small experiments. Writing a short program and seeing it run successfully builds confidence, while errors provide valuable learning experiences. Over time, this approach helped me think like a programmer, breaking tasks into steps and automating repetitive actions—exactly the mindset needed for cloud engineering.

Part 3 — Learning SQL: Managing Data Like a Cloud Engineer

After learning Python, the next critical skill in my cloud engineering journey was SQL (Structured Query Language). SQL is the language used to store, retrieve, and manage data in databases, which are the backbone of almost every application and cloud service. Whether it’s user accounts, transactions, or analytics, understanding SQL allows you to interact with data directly—a skill that is invaluable for cloud engineers, data engineers, and software developers alike.

At first, SQL seemed intimidating. Terms like tables, queries, joins, and keys felt foreign. But once I understood the logic behind how data is organized, it started to make sense. SQL is essentially a way of asking questions to a database, like “show me all users over 18” or “update this record with new information.” Once you grasp that, the language becomes intuitive.

Understanding SQL Concepts

SQL operates on databases, which are collections of structured information. Think of a database as a digital filing cabinet:

• Tables are like folders, each holding rows (records) and columns (fields).

• Records store individual entries, such as a user profile.

• Columns define what type of information each record holds, like name, email, or signup_date.

Here’s an example of a simple table called Users:

Core SQL Skills I Learned

When I started, I focused on core SQL commands that let me interact with data:

1. SELECT – retrieving data from a table

    

   SELECT name, age FROM Users;


   This command shows all users’ names and ages.

2. INSERT – adding new data

    

   INSERT INTO Users (name, age, email)


   VALUES ('Maria', 30, 'maria@email.com');


3. UPDATE – modifying existing data

    

   UPDATE Users


   SET age = 23


   WHERE name = 'Franchesca';


4. DELETE – removing data

    

   DELETE FROM Users


   WHERE name = 'Alex';


5. WHERE – filtering results based on conditions

    

   SELECT * FROM Users


   WHERE age > 22;


6. JOIN – combining data from multiple tables
   
   For example, combining Users and Orders tables to see which users placed which orders.

Hands-On Practice with TechKubo

SQL Playground (Retrieved from Techkubo.com)

For beginners, TechKubo’s SQL Playground is incredibly helpful. You can write SQL queries directly in your browser and see immediate results. I found it especially useful for:

• Practicing SELECT statements and filtering data with WHERE

• Inserting, updating, and deleting records safely

• Understanding relationships between tables using JOINs

The immediate feedback makes learning interactive, and experimenting in a safe environment builds confidence.

Structured Learning with Tutorials Dojo

(Retrieved from TutorialsDojo.com)

While TechKubo lets you practice freely, I also used Tutorials Dojo’s SQL beginner course. The course provides:

• Step-by-step explanations of SQL concepts

• Hands-on exercises that mimic real-world scenarios, like managing a user database or retrieving sales data

• Guidance on more advanced topics like JOINs, GROUP BY, and aggregate functions

By combining TechKubo’s playground with Tutorials Dojo’s structured lessons, I could connect theory with practice, which made SQL feel less intimidating and more applicable to cloud engineering tasks.

Why SQL is Essential for Cloud Engineers

Databases are everywhere in cloud applications. Knowing SQL allows you to:

• Retrieve and analyze data efficiently

• Automate data operations using scripts or cloud services

• Understand how applications interact with data behind the scenes

Even if you don’t become a full-time database administrator, SQL is a foundational skill that makes you a more versatile and capable cloud engineer.

Part 4 — Learning Git and GitHub: Version Control Essentials

After learning Linux, Python, and SQL, I realized that version control is a crucial skill for cloud engineers. Git lets you track changes, manage projects, and collaborate safely, while GitHub provides a cloud platform to store and share your work. Together, they ensure your code and scripts are organized, recoverable, and ready for collaboration.

Git tracks changes to your files, allowing you to revert to previous versions, experiment with new features, and keep a clear history. GitHub extends this capability to the cloud, making collaboration easier and providing a portfolio of your projects.

(Retrieved from: https://codefinity.com/courses/v2/7533d91f-0a23-44a3-afc7-c84d5072e189/5aa6942a-dab9-4c0a-a3c4-                                                                                                                          4e21b6f8fd1b/36a2362a-109b-4662-8b57-af2687f0f02c)

Some core Git concepts every beginner should understand include:

• Repositories – Your project’s home, where Git tracks all changes.

• Commits – Snapshots of your work with descriptive messages.

• Branches – Separate lines of development for testing features without affecting the main project.

• Merges – Combining changes from different branches safely.

• Pull Requests – A collaborative workflow for reviewing and integrating code.

Even basic knowledge of these concepts makes your work organized, safe, and collaborative, which is essential in cloud environments.

Takeaway: Git and GitHub are more than tools—they’re a mindset for managing projects, tracking progress, and collaborating efficiently. Mastering them, even at a basic level, gives you control and confidence in your cloud engineering journey.