January 16, 2025
      No Comments
      Nimesha Jinarajadasa

Understanding Cloud Native

To understand Cloud Native, we first need to know how software works and why physical servers were needed in the past. Let’s break this down step by step in the simplest way possible.

How is Software Created?

Software is essentially a set of instructions written by developers. These instructions are written in programming languages like Python or Java and tell computers what to do.

Examples of software include:

  • A website like YouTube
  • An app like WhatsApp
  • A tool like Microsoft Word

However, writing code is just the first step. That code needs to be run on a computer to work. For small tasks, you can run software on your own laptop. But for bigger tasks, like handling millions of users on YouTube, you need much more powerful computers called servers.

What Are Physical Servers, and Why Were They Needed?

A physical server is a powerful computer designed to run software and handle large amounts of data. In simple terms, a server is like your laptop or desktop computer but much stronger and more reliable.

Here’s how a server differs from your personal computer:

  • Always On: Servers are designed to work 24/7 without breaks. Your laptop might overheat or slow down if it’s running constantly, but servers are built to handle continuous operation.
  • More Power: Servers have more memory (RAM), faster processors, and more storage space to handle complex tasks or multiple users at the same time.
  • Specialized Tasks: Unlike personal computers, servers focus only on running software, storing data, and serving users. They don’t run personal apps or games.

Why were servers needed?

If a website or app had many users, a personal computer wasn’t enough. Servers could handle more traffic and process more data.

Servers could be accessed remotely by users over the internet, allowing software like websites and apps to function globally.

The Challenges of Physical Servers

While physical servers were helpful, they had several drawbacks:

  • High Cost: Companies had to buy and maintain these large computers, which was expensive.
  • Limited Flexibility: If an app got more users, the company had to manually add more servers. This took time and planning.
  • Single Points of Failure: If a server crashed, the app could stop working entirely.
  • Underutilization: Sometimes, companies didn’t fully use their servers. For example, during quiet hours, the servers sat idle, wasting money.

The Cloud: A New Way to Run Software

To solve these issues, cloud computing was introduced. Instead of buying physical servers, companies could now rent virtual servers from a cloud provider like Amazon Web Services (AWS) or Google Cloud. These virtual servers worked like physical ones but had extra advantages:

  • Pay as You Go: Companies paid only for what they used.
  • On-Demand Scaling: More resources could be added instantly if an app got more users.
  • No Maintenance Hassle: The cloud provider handled everything—repairs, updates, and monitoring.

This allowed companies to focus on building their software instead of worrying about hardware.

What is Cloud Native?

With cloud computing came a new way of designing and running software—Cloud Native. Cloud Native is not just about using the cloud; it’s about creating applications that fully take advantage of the cloud’s flexibility and power.

Learn more in this YouTube video.

How Cloud Native is Different from Traditional Methods

Small, Modular Parts (Microservices)

Traditional software was built as one large system. If one part failed, the whole system could stop working.

Cloud Native software is broken into smaller, independent parts called microservices. Each microservice handles one task (e.g., managing users or processing payments). If one part fails, the others keep working.

Learn more about Microservices in this video

Runs in Containers

Instead of running software directly on a server, Cloud Native uses containers. Think of a container as a tiny, portable package that holds everything the software needs to run.

Containers are lightweight, so they start quickly and can run on any server or cloud provider.

Learn more about Containers in this video

Automatic Scaling

Cloud Native applications can automatically handle more users by using more resources from the cloud. For example, during a big sale, an online store can instantly add resources to handle the extra traffic.

Faster Updates

In traditional systems, updating software required downtime. Cloud Native uses tools to roll out updates without stopping the application, ensuring users don’t face interruptions.

Highly Reliable

If one part of the system fails, Cloud Native apps can recover quickly without affecting users. This makes them more resilient.

Why Does Cloud Native Matter?

Cloud Native solves many problems of the old ways of running software:

Efficiency: Save Money by Using Only What’s Needed

In the past, companies had to buy physical servers and set them up, even if they weren’t fully used. This wasted money because those servers often sat idle during quiet times.

With Cloud Native, applications use only the exact amount of resources they need—no more, no less. For example:

  • If fewer people are using an app at night, it automatically scales down, reducing costs.
  • If there’s a sudden surge in users, it scales up instantly, so no resources are wasted.

Speed: Faster Development and Updates

Traditionally, making changes to software (like fixing bugs or adding features) took a long time. Developers had to work on large, interconnected systems, and testing or updating the software often meant downtime.

With Cloud Native:

  • Developers can work on smaller, independent parts of the application (microservices), so changes are faster and safer.
  • Updates can be rolled out without shutting down the app, meaning users get improvements sooner.

For businesses, this means staying ahead of competitors by delivering new features quickly.

Reliability: Fewer Problems for Users

In older systems, if one part of the application failed, the entire system could crash, leaving users frustrated. For example, if a payment service went down, the whole website might stop working.

Cloud Native apps are designed to be more resilient:

  • If one part (like the payment service) has an issue, the rest of the app (like browsing or adding items to the cart) continues to work.
  • Cloud Native apps can quickly recover from failures, ensuring users experience fewer interruptions.

This reliability builds trust and keeps users happy.

Scalability: Grow or Shrink Instantly

In the old days, adding more users required setting up new physical servers, which could take weeks or months. If the demand suddenly dropped, those servers became a waste.

With Cloud Native:

  • Apps can automatically scale up (use more resources) when there’s high demand, like during a holiday sale or a product launch.
  • When demand decreases, they scale down to save costs.

This flexibility allows businesses to handle both busy and quiet periods without extra effort.

In Summary

Cloud Native is a way of building software that takes full advantage of what the cloud offers. It helps create apps that are faster, more reliable, and can handle more users when needed.

The best part is that Cloud Native doesn’t only work in the cloud—it can also be used on physical servers in your own data center (on-premise). It’s a flexible and modern approach that makes software better and easier to manage, no matter where it’s running.

Common Questions About Cloud Native

The key is that Cloud Native focuses on the design of the software, not just where it’s hosted. To explain these concepts in more detail and in a simpler way, we hope to explore them further in a dedicated blog post.