r/CloudandCode • • May 31 '25

AWS Docs Made Me Cry 😭 — Here’s What Finally Helped

0 Upvotes

You ever open an AWS service doc…
…and immediately feel like it was written by a caffeinated robot?

Yeah. Same.

When I first started learning cloud, I thought reading the docs was the “right way” to get good.
So I dove in. Headfirst.

The result?

🧠 Brain = fried
📄 48 open tabs
📌 12 services I couldn't pronounce
🔄 Still no clue what was actually going on

Here’s the hard truth:

AWS is powerful. But it doesn’t hold your hand.

It gives you the tools :
But not the path.
The docs?
Full of facts.
Zero context.

And if you’re like me, you need a story, not a spreadsheet.

So what worked instead?

📌 Using examples I could relate to
📊 Visual breakdowns of services
💬 Real explanations — like a friend walking me through it, not a whitepaper

Once I stopped trying to memorize and started connecting the dots…
Everything clicked.

If you're feeling overwhelmed by cloud learning, trust me:

You don’t need 100 tutorials.
You don’t need to read the entire AWS Well-Architected Framework front to back.

You need clarity.
A system.
And some good old structure that helps you build mental models .......not mental chaos.

P.S. I used a AWS Guide that helped me simplify AWS and actually learn it .......service by service, with visuals, examples, and checklists.

👉 GET YOUR GUIDES

Don’t worry, you’re not behind. You’re just on the messy middle part of learning.
Keep going. It gets better (and clearer).


r/CloudandCode • • Sep 01 '25

5 beginner bugs in Python that waste hours (and how to fix them)

0 Upvotes

When I first picked up Python, I wasn’t stuck on advanced topics.
I kept tripping over simple basics that behave differently than expected.

Here are 5 that catch almost every beginner:

  1. input() is always a string

    age = input("Enter age: ") print(age + 5) # TypeError

✅ Fix: cast it →

age = int(input("Enter age: "))
print(age + 5)

2. is vs ==

a = [1,2,3]; b = [1,2,3]
print(a == b)   # True
print(a is b)   # False

== → values match
is → same object in memory

3. Strings don’t change

s = "python"
s[0] = "P"    # TypeError

✅ Fix: rebuild a new string →

s = "P" + s[1:]

4. Copying lists the wrong way

a = [1,2,3]
b = a      # linked together
b.append(4)
print(a)   # [1,2,3,4]

✅ Fix:

b = a.copy()   # or list(a), a[:]

5. Truthy / Falsy surprises

items = []
if items:
    print("Has items")
else:
    print("Empty")   # runs ✅

Empty list/dict/set, 0, "", None → all count as False.

These are “simple” bugs that chew up hours when you’re new.
Fix them early → debugging gets 10x easier.

👉 Which of these got you first? Or what’s your favorite beginner bug?


r/CloudandCode • • Jun 02 '25

I never understood the hype around CI/CD—until I worked without it

0 Upvotes

One of my first freelance projects was a small web app. No pipelines, no automation, I was SSH-ing into the server and manually copying files like it was 2010.

It worked… until it didn’t.

  • One deploy overwrote the .env file

  • Another time I forgot to restart the service

  • Once I deployed code that wasn’t even tested locally 🤦

After that, I built a basic CI/CD setup with GitHub Actions:

  • Run tests on push

  • Deploy to staging automatically

  • Manual approval to deploy to prod

Nothing fancy.....but everything changed.

Now I get why people obsess over pipelines.
It’s not about speed.......it’s about safety and sanity.

Anyone else go through that “CI/CD awakening”?
What made it click for you?


r/CloudandCode • • Aug 22 '25

15 Days, 15 AWS Services Day 8: Lambda (Serverless Compute)...

0 Upvotes

Lambda is honestly one of the coolest AWS services. Imagine running your code without touching a single server. No EC2, no “did I patch it yet?”, no babysitting at 2 AM. You just throw your code at AWS, tell it when to run, and it magically spins up on demand. You only pay for the milliseconds it actually runs.

So what can you do with it? Tons. Build APIs without managing servers. Resize images the second they land in S3. Trigger workflows like “a file was uploaded → process it → notify me.” Even bots, cron jobs, or quick automations that glue AWS services together.

The way I explain it: Lambda is like a food truck for your code. Instead of owning a whole restaurant (EC2), the truck only rolls up when someone’s hungry. No customers? No truck, no cost. Big crowd? AWS sends more trucks. Then everything disappears when the party’s over.

Of course, people mess it up. They try cramming giant apps into one function (Lambda is made for small tasks). They forget there’s a 15-minute timeout. They ignore cold starts (first run is slower). Or they end up with 50 Lambdas stitched together in chaos spaghetti.

If you want to actually use Lambda in projects, here are some fun ones:

  • Serverless URL Shortener (Lambda + DynamoDB + API Gateway)

  • Auto Image Resizer (uploads to S3 trigger Lambda → thumbnail created instantly)

  • Slack/Discord Bot (API Gateway routes chat commands to Lambda)

  • Log Cleaner (auto-archive or delete old S3/CloudWatch logs)

  • IoT Event Handler (Lambda reacts when devices send data)

👉 Pro tip: the real power is in triggers. Pair Lambda with S3, DynamoDB, API Gateway, or CloudWatch, and you can automate basically anything in the cloud.

Tomorrow: DynamoDB AWS’s “infinite” NoSQL database that can handle millions of requests without breaking a sweat.


r/CloudandCode • • Jul 04 '25

25 Python Resume Projects (FREE for first 10)

0 Upvotes

Big news .... after weeks of work, I’m finally launching something I wish I had when I started learning Python.

It’s called the Python Project Vault.

Inside, you’ll find over 25 real-world Python projects, organized by difficulty, topic, and what you actually learn while building them. These aren’t “build a calculator” kind of tutorials — they’re hands-on projects designed to help you go from just watching to actually doing.

The goal is simple: help you break out of tutorial hell and build a portfolio that shows what you can really do.

Here’s the plan:

✅ Launching in 48 hours
✅ First 10 early supporters get full access for free
✅ After that, it’ll be available for $19

You’ll get project prompts, starter templates, a built-in progress tracker, and everything organized cleanly in Notion.

If you’ve been waiting for something practical and action-focused, this is it.

I’ll post again once the vault is live. If you're part of this subreddit, you're already ahead of the curve.

Let’s build something real.


r/CloudandCode • • 17d ago

swe here, I'm looking to learn more about the cloud, I'm an expert in web dev, but not so much in building cloud architecture/ maintenance/ deployment/ cybersec. anyone interested in friendly networking?

1 Upvotes

thanks, feel free to dm


r/CloudandCode • • Jul 21 '26

Community Discussion Why beginners freeze when the tutorial ends

11 Upvotes

A lot of beginners can follow a tutorial without much difficulty. They understand the explanation, copy the code, get the expected output, and feel like the topic finally makes sense.

Then the tutorial ends.

They open an empty file, try to build something alone, and suddenly have no idea what to do next. I don’t think this always means they failed to understand the tutorial. A lot of the time, the tutorial was quietly making most of the difficult decisions for them. It chose the project, selected the tools, created the folders, structured the code, decided what should happen next, and showed how to fix the errors. While following it, your main job was to understand and reproduce the steps. When you start building alone, all those decisions become your responsibility. You have to decide what to build first, which tools to use, how to structure the project, where to store the data, what should happen when something fails, and when the project is complete enough to stop. That is a different skill.

Take a simple Python weather app.

Inside a tutorial, the instructor may already have selected the API, created the account, installed the requests library, written the function, parsed the JSON response, and handled the errors. You can understand every line and still feel stuck when you try to rebuild the same project without the video. The difficult part is no longer understanding what an API request does. The difficult part is deciding where to begin. Should you create the user input first? Should you test the API separately? Where should the API key be stored? What should happen when the city does not exist? What should the program display when the internet connection fails? Tutorials often hide these decisions because someone else has already made them. Independent projects expose them.

The same thing happens with AWS.

A guided lab may tell you to create an S3 bucket, launch an EC2 instance, configure a security group, attach an IAM role, and copy a command into the terminal. You may complete every step successfully. But when someone asks you to build a cloud project from scratch, the problem changes. Now you have to decide whether the project even needs EC2. You have to think about where the data should be stored, which resources should be public, what permissions are required, how the services communicate, how failures will be monitored, and what could continue costing money after testing. Knowing what each AWS service does is useful. Knowing how to choose between them is a separate skill. That is why many beginners assume they need another course. They think they still cannot build independently because they do not know enough. Sometimes that is true. But often, they already know enough to begin. They simply have not practised making decisions without someone giving them the next step.

The answer is not to stop using tutorials.

Tutorials are useful when you are learning a new concept or tool. The problem begins when you never reduce your dependence on them. After completing a tutorial, close it and rebuild the simplest version from memory. Do not try to recreate every feature. Focus only on the basic flow. Then change one part of the project. Use a different API. Add another input. Store the output in a file. Replace the example dataset. Add error handling. Change the AWS service. Improve the README. That small change forces you to think instead of copy. You are no longer following the exact path someone else created. You are making your own decisions.

Start with requirements, not code.

Before opening your editor, write down what the project should do in plain English. For a weather app, the requirements might be:

The user enters a city. The program requests live weather data. It displays the temperature and condition. It handles invalid cities without crashing.

Those sentences give you direction. Each requirement can become one small task. You do not need to understand the entire solution before starting. You only need to identify the next useful step. This is where many beginners make projects unnecessarily difficult. They imagine the finished version immediately, including authentication, dashboards, databases, cloud deployment, notifications, mobile support, and ten other features. The project becomes overwhelming before the first line is written. A better first version is usually much smaller. A file organiser should successfully move one type of file before supporting every possible format. An expense tracker should save and display one expense before generating reports. An AWS project should solve one clear problem before using ten different services. Finishing a small version teaches more than planning a perfect version that never gets built.

Getting stuck is part of the project.

Debugging feels different when there is no instructor beside you. Inside a tutorial, the instructor already knows which line is wrong. When you build independently, you may not even know which part of the system caused the problem. That can be frustrating, but it is also where real learning starts. You learn how to read the error carefully, test one part at a time, print intermediate values, check the documentation, simplify the problem, and search for the exact behaviour you are seeing. The goal is not to avoid getting stuck. The goal is to become better at getting unstuck. That is one of the most valuable skills independent projects teach. So if you freeze when a tutorial ends, do not immediately assume you need to restart the entire course. Pick one small project. Write the basic requirements. Build the simplest version. Expect the first attempt to be messy. Search when you need help, but avoid copying a complete solution. Use tutorials to learn the tools. Use projects to learn how to make decisions with those tools. The gap between understanding a tutorial and building alone is completely normal. You do not close it by watching forever.

You close it by making small decisions, solving small problems, and finishing small projects without knowing every step in advance.

Where do you usually get stuck when building alone: choosing the idea, starting the project, debugging it, or finishing it?


r/CloudandCode • • Aug 20 '26

AWS & Cloud AWS From Zero #4: What actually happens when you launch an EC2 instance

4 Upvotes

So far in this series, we have talked about cloud fundamentals, setting up an AWS account properly, and understanding IAM. Now we can finally launch something.

EC2 is usually one of the first AWS services beginners touch, and I think it is worth understanding properly before jumping into serverless. The reason is simple. EC2 teaches you what it actually means to run an application on a server.

At the most basic level, EC2 gives you a virtual machine running inside AWS. Instead of buying a physical server, installing it somewhere, connecting it to a network, and maintaining the underlying hardware yourself, you ask AWS to create a virtual machine for you.

But this is where one beginner misunderstanding starts.

Launching an EC2 instance does not mean you automatically have a working website or application.

It only means you now have a machine.

You still need to decide which operating system it runs, what software should be installed, how you will connect to it, which network traffic should be allowed, what application should run there, and how users will eventually reach that application.

When you launch an EC2 instance, one of the first things you choose is an AMI, which stands for Amazon Machine Image. You can think of an AMI as the starting template for the machine. It determines things like the operating system and some of the software that exists when the instance starts.

For a beginner project, you might choose Amazon Linux or Ubuntu. The important thing is not memorizing every available AMI. Just understand that EC2 gives you a machine based on an image you choose.

After that, you select an instance type. The instance type determines the compute resources available to the machine, such as CPU and memory. A small test application does not need the same amount of compute as a large production workload, so AWS gives you different instance sizes for different needs.

At this stage, I would not spend hours comparing instance families. Just understand the idea that different workloads need different amounts and types of compute.

Your EC2 instance also needs storage for the operating system and files. In many beginner setups, you will see EBS used for this. You do not need to learn every EBS option yet. Just understand that the virtual machine and the storage attached to it are related but separate parts of the system.

Now we get to the part that causes a lot of beginner confusion.

Imagine you launch an EC2 instance, install a web server, and start your application. Everything seems to be running correctly inside the machine. You copy the public IP address into your browser, press Enter, and nothing loads.

A lot of beginners assume EC2 is broken at this point.

Usually, the better approach is to follow the request.

Your browser is trying to send a request to the EC2 instance. That traffic has to reach the machine through the network. The network configuration has to allow it. The instance has to accept traffic on the correct port. Then the application itself has to be running and listening on that port.

If any one of those steps is wrong, the page will not load.

This is where security groups start becoming important.

A security group acts like a virtual firewall around resources such as EC2 instances. It controls which network traffic is allowed to reach the instance and which traffic can leave it.

Suppose you are running a normal HTTP website on port 80. Your web server could be running perfectly, but if the security group does not allow inbound HTTP traffic, your browser will not be able to reach it.

The same idea applies when you connect to a Linux EC2 instance using SSH. SSH commonly uses port 22. If the network rules do not allow that connection from your location, you will not be able to connect even though the EC2 instance itself is running normally.

This is also a good place to understand that IAM and security groups solve different problems.

IAM controls permissions to AWS services and APIs. It answers questions such as whether an EC2 workload is allowed to read from S3 or whether a Lambda function is allowed to write to DynamoDB.

Security groups control network traffic. They answer questions such as whether a connection is allowed to reach your EC2 instance on a particular port.

That distinction becomes extremely useful when something breaks.

Imagine your application running on EC2 cannot read an object from S3. Opening another port in the security group probably will not fix the problem. You may be dealing with IAM permissions.

Now imagine the web server works perfectly when tested from inside the EC2 instance, but nobody can reach it through the browser. Adding another S3 permission probably will not fix that either. Now you are more likely dealing with networking, ports, or application configuration.

AWS becomes much easier when you start identifying which layer a problem belongs to instead of randomly changing settings.

Public and private IP addresses are another concept you will keep seeing with EC2.

An EC2 instance has networking inside its VPC, and it can have a private IP address used for communication within that network. Depending on how you configure it, the instance may also be reachable through a public address.

For your first practice project, having an internet reachable instance can be useful because you want to understand the complete path from your browser to the application.

Later, when we learn VPC properly, we will become much more careful about which resources should actually be public.

Not every server should be directly reachable from the internet.

For now, I would keep the project extremely simple.

Launch one Linux EC2 instance. Connect to it. Install a web server such as Nginx. Create a basic HTML page and try to open it from your browser.

The flow you are trying to understand is basically this:

Browser
   ↓
Internet
   ↓
Security Group
   ↓
EC2 Instance
   ↓
Web Server
   ↓
Your Page

That small project teaches much more than it looks like.

You are working with compute, an operating system, ports, network access, security groups, public addresses, and a running application.

And if the page does not load immediately, that is actually useful.

Now you have something real to troubleshoot.

I would start by checking whether the EC2 instance is running. Then I would check whether the web server is actually running inside it. If the application is supposed to use port 80, I would check whether something is listening on port 80.

If everything works inside the instance but not from your browser, that tells you the application itself may not be the problem. Now you start looking at the network path.

Is the security group allowing the traffic you expect? Does the instance have the connectivity it needs? Are you using the correct address? Are you trying to reach the correct port?

That way of thinking is much better than restarting the instance five times and hoping something changes.

You are following the request from beginning to end and finding the first place where the expected flow stops.

That troubleshooting habit will keep coming back throughout this series.

There is another thing beginners should understand early about EC2. Stopping an instance and terminating an instance are not the same thing.

Stopping an instance shuts the virtual machine down so it can generally be started again later. Terminating the instance means you are deleting that EC2 instance.

This matters because closing the AWS console does not mean your infrastructure disappears.

If you launch something for practice and no longer need it, go back and deliberately clean it up. Check what resources still exist and understand what you are leaving behind.

That is part of learning AWS too.

Another habit I would avoid is putting AWS credentials directly inside applications running on EC2.

Imagine your EC2 application eventually needs to read a file from S3. You could create an access key, put it directly inside the source code, and make the application work.

But that is not a pattern I would want a beginner to learn.

A better AWS approach is to give the EC2 instance an appropriate IAM role so the application can receive temporary credentials through AWS instead of storing long lived credentials inside the code.

This is where the previous IAM post starts connecting with EC2.

And that connection is important.

AWS services are not separate topics forever.

Your EC2 instance needs networking. The application running on it may need IAM permissions. The instance uses storage. CloudWatch can help you monitor it. Later, a load balancer may distribute traffic across several EC2 instances, and Auto Scaling may add or remove instances as demand changes.

The services begin to connect because the requirements begin to connect.

That is why I would not try to memorize every EC2 setting before building something.

Launch one instance. Connect to it. Install something. Run a small application. Try to reach it from your browser. When something fails, follow the request and understand why.

That is enough for your first EC2 project.

The main thing I want a beginner to understand from this post is that EC2 gives you compute, not a finished application.

AWS can give you the virtual machine, but you still need to think about the operating system, application, network access, permissions, storage, security, and monitoring depending on what you are building.

Once that idea makes sense, other compute services become easier to understand too.

When we eventually get to Lambda, for example, the idea of running code without managing a server in the same way will make much more sense because you already understand what managing a server actually involves.

For now, keep the project small.

One EC2 instance. One web server. One basic page.

Understand how the request gets from your browser to that page.

That is enough.

In the next post, I want to take the same project and intentionally focus on the part almost every beginner struggles with.

AWS From Zero #5: Your EC2 website is running, so why can’t anyone reach it?

Instead of giving you a random troubleshooting checklist, we will follow the request from the browser all the way to the application and see exactly where it can fail.

If you have already used EC2, what confused you most the first time: SSH, ports, security groups, public IPs, or just figuring out why your website would not load?


r/CloudandCode • • Aug 23 '26

AWS & Cloud AWS From Zero #7: Let’s build a static website with S3 and CloudFront

4 Upvotes

In the last post, we talked about S3 and why it makes more sense when you think about buckets, objects, and keys instead of treating it exactly like a folder on your computer. Now I want to take that idea and actually use S3 inside a small AWS architecture.

For this project, imagine we have a very simple website made with HTML, CSS, JavaScript, and a few images. There is no backend server and no database. The browser only needs somewhere to download those static files from.

We could launch an EC2 instance, install a web server, upload the files, configure the machine, and keep that server running. That would work, but it would also be more infrastructure than this particular website actually needs.

The requirement is much simpler. We need somewhere to store static files and a reliable way to deliver those files to users.

That is where S3 and CloudFront fit together.

Suppose our website contains:

index.html
assets/styles.css
assets/app.js
assets/logo.png

We can upload those objects to an S3 bucket. At that point, S3 solves the storage part of the problem. Our HTML, CSS, JavaScript, and images now have somewhere durable to live.

But storing content and delivering content are two different problems.

One approach you will see in older tutorials is making the S3 content directly public and serving the website from S3. I would not make that the default habit while learning AWS.

A better architecture for this project is to keep the S3 bucket private and put CloudFront in front of it. CloudFront can be given controlled access to retrieve the objects from S3 while users access the website through CloudFront instead of accessing the bucket directly.

The basic architecture becomes:

User
  ↓
CloudFront
  ↓
Private S3 bucket
  ↓
Website files

This is where CloudFront starts making more sense than simply memorizing that it is a CDN.

Imagine someone opens your website. Their browser requests index.html, but instead of sending that request directly to S3, the request reaches CloudFront first.

CloudFront checks whether it already has a valid cached copy of that object. If it does, it can return that copy to the user. If it does not, CloudFront retrieves the object from the S3 origin, returns it to the browser, and may cache it so future requests can be served more efficiently.

The browser then reads index.html and discovers that it also needs styles.css, app.js, and maybe several images. Those files go through the same general process.

Once you follow that request flow, the architecture becomes much easier to understand.

S3 stores the content.

CloudFront sits in front of that content and delivers it to users.

The useful part is that the S3 bucket itself does not need to become publicly accessible just because the website is public.

CloudFront can use Origin Access Control, usually called OAC, so that CloudFront is allowed to retrieve the required objects while direct public access to the S3 bucket remains blocked.

This connects directly with what we learned earlier about permissions.

The question is not, "Should this bucket be public?"

The better question is, "Who actually needs access to these objects?"

In this architecture, CloudFront needs access to retrieve the website content. Random users on the internet do not need unrestricted direct access to the S3 bucket.

Users access CloudFront, and CloudFront accesses S3.

That is a much cleaner way to think about the relationship.

There is one detail worth understanding because it can confuse beginners when they follow different tutorials. S3 can also provide a website endpoint, but the private S3 plus CloudFront architecture we are discussing is different from simply using that website endpoint directly.

For this project, I would think of the S3 bucket as the origin that stores our objects and CloudFront as the public delivery layer in front of it.

That keeps the mental model simple.

Now our website works through CloudFront, but there is another problem.

The CloudFront distribution gives us a generated domain name. That is perfectly fine for testing, but eventually we probably want users to visit something like:

example.com

instead of a generated CloudFront address.

This is where DNS becomes part of the architecture.

If you use Route 53, your domain can point toward the CloudFront distribution. When someone enters your domain, DNS helps their browser find the correct destination, and the request eventually reaches CloudFront.

So our architecture now looks more like:

User enters example.com
        ↓
DNS
        ↓
CloudFront
        ↓
Private S3 bucket
        ↓
Website files

Notice how we are adding services.

We did not start by saying, "Let’s use S3, CloudFront, and Route 53 because these are popular AWS services."

We started with requirements.

The website files need somewhere to live, so we use S3.

Users need a delivery layer, so we add CloudFront.

Users should access the site through a normal domain, so DNS becomes necessary.

Each service has a reason to exist.

That is the architecture thinking I want this series to build.

The next part is HTTPS.

If someone visits your website, you generally want the connection between their browser and your site to be encrypted.

CloudFront can serve the website over HTTPS, and if you use your own custom domain, you can associate an SSL/TLS certificate with the distribution.

You do not need to become a certificate expert for this project. The important idea is understanding where HTTPS fits into the flow.

DNS helps the user reach CloudFront.

The certificate helps establish a secure connection for your domain.

CloudFront delivers the website.

S3 stores the files behind it.

Now a very small static website has already introduced object storage, content delivery, permissions, DNS, HTTPS, and caching without requiring us to manage a server.

That is why I like this as an early AWS project.

The architecture is simple enough to understand, but it still teaches several concepts that show up again in larger systems.

Caching is probably the next thing you will notice once the site is working.

Imagine CloudFront has already cached your styles.css file. You then change the CSS locally and upload the new version to S3.

You refresh the website and somehow still see the old design.

At first, it can look like S3 did not update correctly.

But the issue may simply be that CloudFront is still serving a cached copy.

This is an important lesson because adding caching changes how your application behaves. The latest object can exist in S3 while users temporarily receive another version from the cache depending on how you configured it.

Later, you can learn about cache invalidation, cache-control headers, and using versioned asset names. For example, instead of always using:

styles.css

you might eventually use something like:

styles.v2.css

or let a build system generate unique filenames when the content changes.

You do not need to solve all of that today.

For now, the useful thing is simply understanding that CloudFront caching exists and that it affects the path between your origin and the user.

If I were doing this project as a beginner, I would build it in small stages.

First, create the static website locally and make sure it works before AWS is involved. Then upload the files to S3. After that, create a CloudFront distribution with the S3 bucket as the origin and keep the bucket private.

Once the site works through CloudFront, change something in index.html or your CSS and observe what happens. That gives you a reason to start thinking about caching instead of learning it as another definition.

If you already have a domain, you can then connect it and add HTTPS. If you do not have one, that is completely fine. You can still learn the important part of the architecture using the CloudFront domain.

The goal is not to collect AWS services.

The goal is to be able to explain the complete request.

A user asks for your website. The request reaches CloudFront. CloudFront either serves a cached copy or retrieves the required object from S3. S3 remains the storage layer while CloudFront becomes the layer users interact with.

Once you add a custom domain, DNS helps the user find CloudFront. Once you add HTTPS, the connection between the user and the website can be protected.

That is already a real architecture.

And notice what we did not need.

We did not need an EC2 instance running all day just to serve a few static files. We did not need a database. We did not need Lambda. We did not need ten additional AWS services simply to make the architecture look impressive.

We used the services that matched the requirements.

That is the habit I want beginners to develop.

Do not ask, "How many AWS services can I put in this project?"

Ask, "What does the application need, and which service solves each requirement?"

For this lesson, the most important flow to understand is simply:

Browser
  ↓
CloudFront
  ↓
S3

Then gradually add the reasoning around it.

S3 stores the objects. CloudFront delivers them. OAC helps CloudFront access the private S3 origin. DNS can connect a custom domain to the site. HTTPS protects the connection with users. Caching can improve delivery but also changes how updates reach users.

If you can explain all of that in your own words, you have learned much more than someone who simply followed a console tutorial until a website appeared.

That is the bigger goal of AWS From Zero.

We are not trying to memorize where every button is in the AWS console.

We are trying to understand why the architecture works.

In AWS From Zero #8, we are going to properly tackle VPC networking. Instead of memorizing public subnets, private subnets, route tables, internet gateways, NAT gateways, and security groups separately, we will put them into one simple application and follow the traffic through the network.

That is where a lot of the networking concepts we touched during EC2 will finally start connecting.

If you were building this S3 and CloudFront website, what would you want to understand next: keeping the bucket private, caching, DNS, or HTTPS?


r/CloudandCode • • Aug 28 '26

AWS & Cloud AWS From Zero #11: API Gateway makes more sense when you think of it as the front door to your backend

5 Upvotes

In the last post, we talked about Lambda and why serverless makes more sense once you understand what running an application on EC2 actually involves. Lambda gives us a way to run code when something happens without managing a server in the same way we would with EC2.

But there is still an obvious question.

If we want someone on the internet to use our Lambda function, how do they actually reach it?

Imagine we are building a simple task application. A user should be able to create a task, view existing tasks, update one, or delete one. The business logic can run inside Lambda, but we still need something that can receive HTTP requests from the user and send those requests to the correct backend logic.

This is where API Gateway starts making sense.

I would think of API Gateway as the front door to your backend.

A client sends a request to API Gateway. API Gateway receives that request and routes it to the backend integration you configured. In our beginner serverless application, that backend can be Lambda.

The basic flow looks like this:

Client
  ↓
API Gateway
  ↓
Lambda
  ↓
Database

Then the response travels back in the opposite direction:

Database
  ↓
Lambda
  ↓
API Gateway
  ↓
Client

The important thing is understanding what each service is responsible for.

API Gateway receives and routes the HTTP request.

Lambda runs the application logic.

The database stores the application data.

That separation becomes much easier to understand when we use a real example.

Suppose the user wants to create a new task. Their application might send a request like:

POST /tasks

with some data:

{
  "title": "Learn API Gateway"
}

API Gateway receives the request and sends the relevant information to Lambda. Lambda reads the input, checks whether the task is valid, stores it in a database, and returns a response.

That response might contain something like:

{
  "task_id": "123",
  "title": "Learn API Gateway"
}

along with an HTTP status code such as 201 Created.

Now suppose the user wants to retrieve their tasks.

The request could be:

GET /tasks

API Gateway receives that request and invokes the appropriate backend logic. Lambda reads the tasks from the database and returns them.

The architecture has not become complicated.

We have simply given users a controlled HTTP entry point into our application.

This is why I would not memorize API Gateway as just "a service for creating APIs."

Think about the problem it solves.

Your Lambda function contains backend logic, but users need a predictable way to send requests to that logic.

API Gateway gives you that entry point.

This is also where HTTP methods start having a practical purpose.

GET usually means we want to retrieve something.

POST commonly means we want to create something.

PUT or PATCH can be used when updating something.

DELETE is used when removing something.

You may have already seen these while learning REST APIs, but now they become part of an actual AWS architecture.

Our task application could eventually have requests such as:

GET    /tasks
POST   /tasks
GET    /tasks/123
PATCH  /tasks/123
DELETE /tasks/123

Each route describes something the client wants the backend to do.

The interesting part is that API Gateway itself should not contain all of your business logic.

If someone sends:

POST /tasks

API Gateway can receive and route that request, but your Lambda function might be responsible for deciding whether the title is valid, creating the task, and storing it.

This separation helps keep the architecture easier to reason about.

Now imagine someone sends invalid data.

Maybe they send:

{
  "title": ""
}

Your application should not blindly create an empty task.

The request needs to be validated somewhere in the flow.

Depending on how you design the API, some validation can happen at the API layer, while your application logic should still validate important assumptions before acting on the data.

If the input is invalid, the API might return something like:

400 Bad Request

If the task does not exist:

404 Not Found

If the task is created successfully:

201 Created

If something unexpectedly fails inside the application:

500 Internal Server Error

These status codes are useful because the client needs more information than simply "the request finished."

The client needs to know what happened.

This is an important shift when moving from small Python scripts into APIs.

You are no longer writing code only for yourself.

Another application is communicating with your backend, so the contract between them matters.

The request format matters.

The response format matters.

The status code matters.

The errors matter.

Now let’s connect this back to Lambda.

When API Gateway receives a request, Lambda can receive information about that request. Depending on the API and integration you configure, that can include things such as the HTTP method, path, query parameters, headers, and request body.

Suppose the request is:

GET /tasks/123

The 123 can be passed to the backend as part of the request path.

Lambda can then use that ID to retrieve the correct task.

Or imagine a request like:

GET /tasks?status=completed

Now status=completed is a query parameter.

Lambda could use that value to determine which tasks should be returned.

You do not need to memorize every event structure immediately.

The important thing is understanding that API Gateway receives an HTTP request and passes useful request information to your backend.

Now another AWS concept comes back into the architecture: permissions.

API Gateway needs to be able to invoke the Lambda function.

This does not mean we should give API Gateway unlimited permissions across our AWS account.

We want the specific relationship required by the architecture.

API Gateway needs permission to invoke the Lambda function it is integrated with.

Then Lambda may need its own permissions.

If Lambda writes to DynamoDB, its execution role needs the relevant DynamoDB permissions.

If Lambda reads from S3, it needs the relevant S3 permissions.

Once again, the same IAM mental model works.

Who is making the request?

What action are they trying to perform?

Which resource are they trying to access?

That question keeps appearing because IAM sits underneath so many AWS interactions.

Now suppose our API does not work.

The client sends:

POST /tasks

but receives an error.

Do not immediately rebuild API Gateway.

Follow the request.

Did the request reach API Gateway?

Did API Gateway invoke Lambda?

Did Lambda start running?

Did Lambda receive the data you expected?

Did the function fail while processing it?

Did it have permission to access the database?

Did it return the response format the API expected?

This is the same troubleshooting habit we used with EC2, S3, and VPC.

Follow the flow until you find the first place where expected behavior stops.

CloudWatch becomes useful here again.

If Lambda runs and throws an exception, the logs can help you understand what happened.

Maybe the JSON body was malformed.

Maybe a required field was missing.

Maybe the DynamoDB request failed.

Maybe the function timed out.

Maybe the function returned something unexpected.

Instead of saying "the API is broken," try to identify which part of the request path actually failed.

There is another concept you may encounter quickly if you call your API from a browser: CORS.

Imagine your frontend is served from one domain and your API lives at another origin. The browser applies security rules around cross origin requests.

This can produce the frustrating situation where your API works when tested directly with a tool such as curl or Postman, but the browser blocks the frontend request.

That does not necessarily mean Lambda failed.

It may mean the browser did not receive the cross origin permissions it expected.

You do not need to become a CORS expert for your first API, but it is worth knowing that browser security can be another layer in the request flow.

Again, understanding the layer matters.

A browser CORS error is not automatically an IAM problem.

An IAM AccessDenied error is not automatically a routing problem.

A Lambda exception is not automatically an API Gateway problem.

The better you become at identifying which layer failed, the faster AWS troubleshooting becomes.

API Gateway also gives us another important architecture idea: the public interface of your application does not need to expose how the backend is implemented.

The client knows that it can send:

POST /tasks

It does not necessarily need to know which Lambda function handles the request, where the data is stored, or how the backend infrastructure is organized.

That implementation can change later while the API contract remains relatively stable.

Maybe today the backend uses Lambda.

Maybe another architecture uses containers.

The client still cares about the API it communicates with.

That separation becomes valuable as systems grow.

For your first API Gateway project, though, I would keep everything extremely small.

Do not build authentication, payments, queues, caching, ten Lambda functions, and a complicated database design immediately.

Build one endpoint first.

Something like:

GET /hello

Have API Gateway invoke Lambda.

Have Lambda return:

{
  "message": "Hello from AWS"
}

Then understand the complete request path.

Once that works, add a POST endpoint.

Then read some input from the request.

Then validate it.

Then connect a database.

Grow the architecture one requirement at a time.

A simple task API would be enough for this stage.

You could eventually support creating tasks, retrieving them, updating them, and deleting them.

But the important learning is not the task manager itself.

The useful part is understanding how a request enters AWS, reaches your code, interacts with another service, and returns a response.

At this point in the series, our serverless architecture might look like:

Client
  ↓
API Gateway
  ↓
Lambda
  ↓
Database

That is already enough to build a real backend.

And notice how the previous lessons start connecting.

IAM controls permissions.

Lambda runs our code.

API Gateway receives HTTP requests.

CloudWatch helps us understand failures.

Soon we need somewhere appropriate to store the application data.

That brings us to the next post.

In AWS From Zero #12, we are going to learn DynamoDB.

But I do not want to explain it as simply "AWS NoSQL database."

We will compare it with the relational model we saw with RDS and focus on one of the most important DynamoDB ideas: designing around how your application actually accesses its data.

That is where the difference between RDS and DynamoDB becomes much clearer.

For now, if you can explain the path from a POST /tasks request to Lambda and back to the client, you already understand the most important idea behind this lesson.

If you have built an API before, what confused you more at first: routes, status codes, Lambda integration, permissions, or CORS?


r/CloudandCode • • Jun 30 '26

Most beginners use GitHub like storage. They should use it like proof.

53 Upvotes

A lot of beginners treat GitHub like a place to dump code.

They finish a project.

Upload the files.

Add a one-line README.

Then move on to the next project.

That is better than keeping everything on your laptop, but it still misses the main point.

GitHub is not just storage.

GitHub is proof.

It shows what you built, how you think, how you explain your work, and whether someone else can understand the project without sitting next to you.

That matters.

Especially if you are learning Python, AWS, SQL, cloud, data, or backend development.

A messy GitHub repo can make a decent project look weak.

A clear GitHub repo can make a simple project look serious.

The difference is usually not the project size.

It is how well you present it.

For example:

A Python file organizer with no README looks like a random script.

But the same project with a clear explanation, setup steps, screenshots, and before/after examples looks like a useful automation project.

A basic AWS deployment with no notes looks like you clicked around the console.

But the same project with an architecture diagram, service choices, IAM notes, and cost awareness looks like you understand what you built.

A SQL project with only query files looks incomplete.

But the same project with a dataset explanation, business questions, queries, insights, and screenshots looks much more practical.

That is the difference.

Your GitHub should answer simple questions:

What does this project do?

Why did you build it?

What problem does it solve?

What tools did you use?

How can someone run it?

What did you learn?

What would you improve?

Most beginners skip these questions.

Then they wonder why their portfolio does not look strong.

The code matters.

But the explanation around the code matters too.

A good beginner repo should usually have:

A clear project title.

A short description.

A proper README.

Clean folder structure.

Setup instructions.

Screenshots or sample output.

List of tools used.

What you learned.

Problems you faced.

Future improvements.

You do not need a perfect project.

You need a project that someone can understand.

That is the point of GitHub.

It is not just for saving code.

It is for showing your thinking.

This is why two people can build the same beginner project and one portfolio looks much stronger than the other.

One person uploads files.

The other person explains the project.

That explanation creates proof.

If you are using GitHub as a beginner, do not treat it like a backup folder.

Treat every repo like a small case study.

Even a simple project can look useful when it is presented clearly.

And even a good project can look unfinished when it is not explained well.

If people want, I can share a simple GitHub project checklist beginners can use before adding a project to their portfolio.


r/CloudandCode • • Sep 16 '26

Community Discussion What is actually stopping you from building projects right now?

24 Upvotes

I see a lot of people learning Python, AWS, SQL, GitHub, or cloud concepts for months, but still struggling to actually start building something on their own. Most of the time, I do not think the problem is a lack of tutorials. There is already more learning material available than anyone could realistically finish.

The difficult part usually starts when the tutorial disappears and you have to make decisions yourself. You need to choose a project, decide what the first version should include, structure the code, fix things when they break, and somehow figure out whether you are even doing it the "right" way. That gap between learning a concept and building without someone guiding every step is where I think a lot of people get stuck.

So I am curious about what the biggest blocker actually is for people here right now. I also want to use the answers to decide what kind of practical posts, projects, debugging threads, and walkthroughs would be most useful in this community over the next few weeks.

What is currently stopping you from building more projects?

Poll options:

  • I don't know what to build

  • I know what to build, but don't know how to start

  • I get stuck when something breaks

  • I keep going back to tutorials

  • I don't have enough time

  • Something else

If your answer is "something else," drop it in the comments. I am especially interested in the point where you normally stop making progress, because that is probably more useful to talk about than another generic list of projects to build.


r/CloudandCode • • Oct 09 '26

DevOps Case Study: I rebuilt a Terraform-style AWS setup with Pulumi to see where it actually feels different

8 Upvotes

I have been using Terraform as the default example whenever I talk about Infrastructure as Code because it is one of the easiest tools to recognize in cloud and DevOps discussions. But I wanted to look at Pulumi from a more practical angle, not as another “Terraform killer” post. The question I wanted to answer was much simpler: if I already understand AWS infrastructure, what changes when I describe the same infrastructure using a programming language instead of HCL?

For this case study, I imagined a fairly normal small AWS application rather than a huge enterprise environment. The requirement was to create a VPC, networking, security groups, an Application Load Balancer, an ECS service, an RDS database, an S3 bucket, and the IAM permissions required by the application. This is complex enough to expose the differences between the tools without turning the comparison into a 5,000-resource platform.

With Terraform, I would normally describe the infrastructure using HCL. A resource is declared, its arguments are configured, outputs from one resource are passed into another, and Terraform builds the dependency graph. Once you understand the Terraform workflow, the model is predictable: write configuration, run terraform plan, review the proposed changes, and then run terraform apply.

Pulumi keeps the Infrastructure as Code idea, but changes the way I express it. Instead of learning a configuration language specifically for infrastructure, I can write the infrastructure using languages such as TypeScript, Python, Go, C#, Java, or JavaScript. For someone who already spends most of the day writing application code, that feels immediately different.

A tiny example makes the difference obvious.

With Terraform, an S3 bucket might look roughly like this:

resource "aws_s3_bucket" "uploads" {
  bucket = "example-app-uploads"
}

With Pulumi using Python, the same idea can look closer to normal application code:

import pulumi_aws as aws

uploads = aws.s3.Bucket(
    "uploads",
    bucket="example-app-uploads"
)

At this level, the difference is mostly syntax. I do not think choosing Pulumi because Python looks more familiar is enough reason by itself to replace Terraform. The more interesting difference appears when the infrastructure starts containing real logic, reusable abstractions, validation, loops, configuration, and relationships between many resources.

Imagine I want to create several similar S3 buckets, security rules, or application components based on configuration. In Pulumi, I can use the same language features I already use in normal software: functions, classes, loops, conditionals, packages, testing tools, and type systems where the language supports them. I do not have to mentally switch between “programming code” and “infrastructure configuration” as much.

That can make reusable infrastructure feel very natural. I could create a Python function or TypeScript component that represents something like a standard application service, and that component could create the load balancer configuration, ECS resources, IAM role, logging, and other pieces required by that service. The team can then reuse that abstraction instead of copying the same infrastructure definitions into multiple places.

This is probably the part of Pulumi I find most interesting.

Infrastructure begins to feel like a software library.

But that strength can also become a weakness.

If I give developers a full programming language, they can build much more sophisticated abstractions. They can also build abstractions that are much harder to understand than the infrastructure underneath them. A simple Terraform directory with explicit resources can sometimes be easier to review than a Pulumi project where resources are created through several classes, helper functions, conditions, and internal libraries.

So I would not describe Pulumi as automatically cleaner than Terraform.

It gives me more expressive power.

Whether that becomes cleaner or more complicated depends heavily on how the team uses it.

State is another area where I initially expected Pulumi to feel completely different, but the underlying problem still exists. An Infrastructure as Code tool needs some way to understand the relationship between the resources defined in code and the resources that actually exist in the cloud. Pulumi maintains state for this reason, just as Terraform has state as a central part of its workflow.

Pulumi can use Pulumi Cloud for state and related management features, and there are also options for using other supported backends depending on how you want to operate it. The important lesson for me is that using a general-purpose programming language does not remove the infrastructure state problem. You still need to think about where that state lives, who can access it, how teams collaborate around it, and how environments are separated.

The workflow is also familiar enough that the transition is not as strange as I expected.

With Terraform, I am used to:

Write configuration
        ↓
terraform plan
        ↓
Review changes
        ↓
terraform apply

With Pulumi, the mental flow is similar:

Write infrastructure code
        ↓
pulumi preview
        ↓
Review changes
        ↓
pulumi up

That similarity matters because one of the most valuable parts of Infrastructure as Code is not the syntax. It is the ability to inspect what is about to change before I change the environment.

For this AWS example, I would probably structure the Pulumi project around reusable pieces instead of putting the entire architecture into one massive Python or TypeScript file. Networking could be one component, the application service another, the database another, and shared configuration could define differences between development and production.

That gives me another benefit: application developers can understand more of the infrastructure without learning an entirely separate language first. If a team already uses TypeScript heavily, a TypeScript Pulumi project may feel much more approachable than introducing another syntax solely for infrastructure.

But I also think Terraform has a major advantage here that should not be ignored: familiarity.

A huge number of cloud engineers already know Terraform. There is an enormous amount of existing Terraform code, documentation, examples, community discussion, modules, and organizational knowledge around it. If I join a company and they already have hundreds of Terraform modules working reliably, replacing that environment with Pulumi just because I prefer Python would probably create more problems than it solves.

This is why I think the “Pulumi vs Terraform” discussion becomes much more useful when the question changes from which tool is better? to which workflow fits this team better?

If I have a software-heavy team that wants to build internal infrastructure abstractions using TypeScript or Python, reuse normal testing patterns, and treat infrastructure code like the rest of the software stack, Pulumi becomes very attractive.

If I have an infrastructure team with years of Terraform experience, established modules, existing automation, and engineers who value a specialized declarative configuration format, Terraform may remain the simpler decision.

There is also a testing angle I like with Pulumi. Because the infrastructure lives inside a real programming language, I can use familiar testing patterns around some parts of the infrastructure code. That does not mean unit tests magically prove the cloud environment will behave perfectly, but it gives me more familiar tools for validating infrastructure logic and reusable components before deployment.

The biggest mistake I would avoid is choosing Pulumi because it lets me say, “Now I can write infrastructure in Python.”

That is a nice developer experience benefit, but it is not the architectural reason to use it.

The stronger reason is that a full programming language gives me a different way to build abstractions, share infrastructure components, test logic, and integrate infrastructure development into the rest of the software engineering workflow.

For a beginner, I would still recommend understanding the infrastructure manually before going too deep into either tool. If you do not understand what a VPC, security group, load balancer, IAM role, or ECS service is doing, writing it in Python instead of HCL does not suddenly make the architecture understandable.

The tool should automate infrastructure you already understand.

It should not hide infrastructure you never learned.

If I were learning Pulumi from scratch, I would start with a very small AWS project. I would create something like an S3 bucket, then add IAM configuration, then create a small EC2 or Lambda setup. I would run pulumi preview, inspect exactly what is going to change, deploy it, modify the code, observe the update, and finally destroy the practice environment.

Only after understanding that lifecycle would I move into reusable components and larger architectures.

My takeaway from this case study is that I would not call Pulumi a direct “better Terraform.” I would call it a different approach to the same Infrastructure as Code problem.

Terraform asks me to describe infrastructure primarily through a purpose-built configuration language and its surrounding ecosystem.

Pulumi lets me describe infrastructure using the programming languages and software engineering tools I may already be using elsewhere.

Both approaches can create good infrastructure.

Both can also create terrible infrastructure if I do not understand what I am building.

For me, the real decision would come down to the team, existing infrastructure, abstraction needs, language preferences, ecosystem requirements, and how much value we actually get from treating infrastructure more like application code.

If you had to start a completely new AWS project today with no existing IaC codebase, would you choose Terraform or Pulumi, and what would be the reason behind that choice?


r/CloudandCode • • Sep 27 '26

Debugging Help One thing that improved my projects a lot was deliberately trying to break them

11 Upvotes

For a long time, I used to test projects in the easiest possible way. I would run the program, give it the exact input I expected, see the correct output, and assume everything was working. That is fine when you are building the first version, but I eventually realized that a project is not really tested just because the happy path works once.

Now, after I get the basic version working, I intentionally start giving the application bad situations. If a Python script expects a number, I give it text. If an API expects a field, I remove it. If a file is supposed to exist, I rename it. If the database connection is required, I deliberately break the credentials. The goal is not to make the project fail. The goal is to understand how it fails.

That small change made debugging much more useful for me because I stopped treating every error as something unexpected. Some failures should be expected. The real question becomes whether the application handles them properly. Does it crash with a confusing traceback, return a useful error, retry something that is safe to retry, or quietly produce the wrong result?

Take a simple expense tracker as an example. The first version might accept an amount, category, and date, then save everything into a CSV file. It works perfectly when I enter 250, Food, and a valid date. But what happens when I type two hundred as the amount, leave the category empty, enter an impossible date, or delete the CSV file before starting the program?

Those cases teach much more than running the perfect input twenty times. Suddenly I need validation, exception handling, sensible defaults, and error messages that actually explain what happened. I also start noticing assumptions in my own code that I did not realize I was making.

The same idea becomes even more useful with APIs. Suppose I build an endpoint that creates a user. I would test the normal request first, but then I would send the request without an email, submit an email that already exists, send invalid JSON, remove database access, or make one dependency unavailable. Each failure forces me to think about what response the API should return instead of just hoping nothing ever goes wrong.

This is also where HTTP status codes started making more sense to me. A malformed request should not look the same as an internal application failure. A missing resource should not return the same response as a database timeout. When you deliberately create those situations, concepts like 400, 404, 409, and 500 stop being things you memorize and start becoming decisions you actually need to make.

Cloud projects become even more interesting because there are more places where things can fail. I might remove an IAM permission and see what my Lambda function logs. I might change a security group rule and watch what happens to connectivity. I might stop one backend instance behind a load balancer and see whether health checks detect it. I might make an SQS consumer fail repeatedly and watch when the message ends up in the dead-letter queue.

I think this is one of the easiest ways to understand AWS beyond the console. Instead of only learning what a service does when everything is configured perfectly, you learn what evidence it gives you when something is wrong. The AccessDenied message, unhealthy target, timeout, failed health check, growing queue, or CloudWatch log suddenly becomes part of the learning instead of an interruption to it.

It also changed how I think about testing. I used to think testing mainly meant writing unit tests after the project was finished. Now I think about it more broadly. What assumptions is this code making, what input could violate those assumptions, what dependency could become unavailable, and what should happen when that occurs?

Once I know those cases, automated tests become much easier to write because I already understand the behaviours I care about. I can test that valid input succeeds, invalid input is rejected, duplicate data is handled properly, and important functions still behave correctly after I refactor them.

The interesting part is that you do not need a complicated application to practise this. Take any beginner project you already built and spend thirty minutes trying to break it. Do not add a new feature during those thirty minutes. Just use inputs and situations the original version probably never expected.

You will usually discover more things to improve than you would by immediately adding another feature.

Maybe your program crashes when a file is missing. Maybe one function accepts values it should reject. Maybe the API exposes a confusing error. Maybe a database query fails silently. Maybe your application depends on one environment variable that you never documented.

Every one of those failures gives you another design decision to make.

I also think this makes projects easier to talk about in interviews or portfolio discussions. Saying, “I built an API” is fine. Being able to explain, “I tested what happened when the database became unavailable, noticed the application returned an unclear 500 response, improved the error handling, added logging, and wrote a test so the same bug would not return” tells a much better story.

The project itself did not necessarily become much bigger.

You just understood it more deeply.

So before starting another tutorial this weekend, I would take one project you already have and try to break it on purpose. Give it bad input, remove something it depends on, make one service unavailable, and see whether you can explain exactly what happens.

What is the most unexpected way one of your projects has broken so far?


r/CloudandCode • • Jul 14 '26

Knowing what an AWS service does is not the same as knowing when to use it

11 Upvotes

A lot of beginners think they understand AWS because they can explain what the main services do. EC2 is a virtual server, S3 stores files, Lambda runs code without managing servers, RDS is a managed database, CloudFront delivers content faster, and IAM controls permissions.

But when they are given a real project and asked which services they would use, they suddenly feel stuck. I don’t think this means they have not learned enough AWS. A lot of the time, they understand the definitions, but they have not yet learned how to make decisions with those services.

Knowing what a service does and knowing when to use it are two different skills.

Take a simple portfolio website.

The website only contains HTML, CSS, JavaScript, and a few images. There is no login system, database, backend, or server-side logic. A beginner might choose EC2 because they know websites run on servers, and technically, EC2 could host the website.

But using EC2 also means launching an instance, connecting through SSH, installing a web server, configuring security groups, managing the operating system, applying updates, and keeping the instance running. That may be more infrastructure than a simple static website actually needs.

S3 may be a better starting point because it can store and serve the website files without requiring you to manage a server. You could then add CloudFront for content delivery, Route 53 for a custom domain, and HTTPS for secure access.

The website has not changed. The requirement is still the same. But the architecture is now simpler and requires less management.

That is the real AWS skill. It is not only knowing that EC2 exists. It is recognising when you do not need EC2.

The same thing happens with automation.

Imagine you have a Python script that generates a report every morning. It runs for two minutes and then stops. You could launch an EC2 instance, keep it running throughout the day, and use it to execute the script once.

That would work, but Lambda with EventBridge may make more sense. The task is short, scheduled, and does not need a server running continuously. Lambda is not automatically better than EC2, but its execution model fits this particular requirement more naturally.

The decision should come from the problem. How long does the code run? How frequently does it need to run? Does it need a full operating system? Does anything need to remain active after the task is complete? How much infrastructure do you want to manage?

Those questions are more useful than memorising another service definition.

Database decisions work in the same way.

RDS and DynamoDB both store data, but that does not mean they should be used for the same type of application. RDS may make sense when your data has structured tables, clear relationships, and a need for SQL queries. DynamoDB may make sense when your access patterns are well understood and you need a highly scalable, serverless database with fast key-based access.

The important question is not which database is more popular. The important questions are how the data is structured, how the application will access it, whether records have relationships, and how the workload is expected to scale.

These are architecture decisions, and architecture decisions cannot be made by memorising definitions alone.

The same pattern appears across AWS. S3 seems simple until you need to decide whether objects should be public or private. IAM seems simple until one service needs permission to access another. VPC seems simple until you need to decide which resources should be publicly accessible and which should remain private.

CloudWatch seems unimportant until your application fails and you need to understand what happened. Lambda seems simple until you need to think about permissions, triggers, timeouts, retries, and execution limits.

That is why AWS often starts feeling harder after the beginner stage. Learning the names is not the hardest part. Making the right decisions is.

A good AWS project should not only list the services that were used. It should explain the problem being solved, why those services were selected, why the alternatives were not selected, how the services communicate, what permissions are required, how failures would be monitored, and what could increase the cost.

Most beginners skip that part. They memorise services separately, complete a few guided labs, and then feel confused when they have to design something independently.

The solution is not always learning another twenty AWS services. Sometimes the better approach is taking one small project and asking better questions.

Does this project need a server? Is the content static or dynamic? Where should the data be stored? Who needs permission to access it? How will traffic reach the application? What happens if one part fails? How will I know that something has gone wrong? Which resources could continue costing money after I finish testing?

That is how AWS starts becoming practical. You stop seeing services as separate definitions and start seeing them as tools for different requirements.

Knowing AWS is not just being able to explain what EC2, S3, Lambda, RDS, or IAM does. It is being able to say, “I chose this service because it fits the requirement, and I avoided the alternatives because they would add unnecessary cost, complexity, or management.”

That is the type of thinking AWS projects should teach.

Which AWS service do you understand in theory but still struggle to use in a real project?


r/CloudandCode • • Sep 26 '26

SQL & Data If I were learning SQL again, I would stop practising random queries and start answering real questions

33 Upvotes

If I were learning SQL from zero today, I would not spend weeks solving disconnected exercises like “find the second highest salary” without understanding what the data actually represents. Those questions can be useful for syntax practice, but after a point they start feeling like puzzles instead of something you would genuinely use while working with data. I would rather take one realistic dataset and keep asking better questions about it.

Imagine I have a simple ecommerce database with customers, products, orders, and order items. At the beginning, I might only write basic queries such as finding all orders from the last thirty days or listing customers from a particular city. That is enough to practise SELECT, WHERE, ORDER BY, and filtering without making the project unnecessarily complicated.

Once those queries feel comfortable, I would start asking questions that require multiple tables. Which customers have never placed an order? Which products generate the most revenue? What is the average order value? Which customers have purchased more than five times? Now joins stop being something I memorized from a diagram and start becoming the tool I need to answer an actual question.

This is also where GROUP BY, aggregate functions, and subqueries begin to make much more sense. Instead of practising SUM() because it happens to be in the syllabus, I now need it because I want to calculate monthly revenue. Instead of learning COUNT() in isolation, I need it because I want to know how many orders each customer placed. The SQL concept becomes easier to remember because I know why I used it.

Then I would make the questions slightly more realistic. Maybe I want to know which products are growing month over month, which customers have stopped purchasing, which categories have high sales but low repeat purchases, or what percentage of revenue comes from the top ten customers. These are no longer just syntax exercises. They start forcing me to think about the data before I even write the query.

I think that is an underrated part of learning SQL. Writing a query is only half of the skill. The other half is understanding what the result actually means. A query can run perfectly and still answer the wrong question because the joins are incorrect, duplicate rows changed the totals, null values were ignored, or the business definition was never clear in the first place.

For example, imagine you join customers to orders and then orders to order items. Suddenly one order can appear several times because it contains several products. If you calculate something at the order level without noticing that duplication, the query might return a believable number that is completely wrong. SQL becomes much more interesting once you start debugging incorrect answers instead of only debugging syntax errors.

I would also deliberately include messy data in the project. Some customers should have no orders. Some fields should contain nulls. There should be cancelled orders, duplicate-looking records, and dates across several months. Real datasets are rarely perfectly clean, and learning what to do with imperfect data teaches much more than practising only on tables where every row behaves exactly as expected.

After that, I would create a small set of questions and save every solution in GitHub. I would include the database schema, sample data, the SQL queries, and a short explanation of what each query is trying to answer. I would probably also include a few cases where my first query was wrong and explain what caused the mistake. That tells a much better story than uploading a folder containing fifty unrelated SQL exercises.

The project does not even need a huge dataset. Four or five well-designed tables can teach joins, aggregation, filtering, window functions, CTEs, subqueries, and data modelling if you keep increasing the quality of the questions you ask. I would rather understand one small database deeply than download a massive dataset and barely understand what any of the columns mean.

If I were making the project portfolio-ready, I would eventually add a final section with maybe ten useful findings from the data. Not because I am trying to turn a SQL project into a business report, but because it proves that I can move from raw tables to an actual conclusion. That is usually much closer to how SQL is used in real work than simply demonstrating that I know the syntax for a LEFT JOIN.

So if you are currently learning SQL, try changing the question from “Which SQL topic should I practise next?” to “What question do I want this data to answer?” Once you have a real question, the SQL concepts you need usually become much clearer.

If I post a complete beginner SQL project next, would you rather build an ecommerce analysis, subscription business analysis, job application tracker, or personal finance database?


r/CloudandCode • • Oct 03 '26

AWS & Cloud Cloud computing made more sense to me once I stopped thinking of it as “someone else’s computer”

16 Upvotes

When I first started learning cloud computing, the explanation I kept hearing was that “the cloud is just someone else’s computer.” That is not completely wrong, but I do not think it is very useful either. It makes cloud sound like nothing more than renting a remote server, when the more interesting part is really about how quickly you can get infrastructure, how easily you can change it, and how much of the underlying work you can hand off to a provider.

If I buy a physical server for an application, I have to think about the machine itself, where it lives, how much capacity I need, what happens if it fails, how long replacement takes, and whether I bought too much or too little. In the cloud, I can request compute, storage, networking, databases, and other services when I need them, then change or remove them much faster than I could with physical infrastructure.

That difference matters because applications rarely stay exactly the same. A small project might have almost no traffic today and suddenly need more capacity later. With cloud infrastructure, I can increase resources, run more instances, distribute workloads, or move parts of the system into managed services without buying and installing new hardware every time the requirements change.

This is where concepts like scalability and elasticity started making more sense to me. Scalability is about whether the system can handle more work as demand grows. Elasticity is about adjusting resources as that demand changes. If traffic increases for a few hours and then drops again, I do not necessarily want to permanently run enough infrastructure for the busiest possible moment.

Another thing I misunderstood early was the idea of “pay only for what you use.” Cloud pricing is not automatically cheap. It simply changes the model. Instead of buying infrastructure upfront, you generally pay based on the resources and services you consume. That can be very efficient when the architecture matches the workload, but it can also become expensive if resources are oversized, left running, or designed without any thought about cost.

The cloud also gives you different levels of responsibility. With a virtual machine like EC2, you still manage the operating system, application runtime, patches, and much of the software stack. With a managed database like RDS, AWS takes over more of the database infrastructure work. With something like Lambda, AWS manages even more of the underlying compute while you focus mainly on your function and its configuration.

I think this is one of the most useful ways to understand cloud services. Every managed service is really a decision about which responsibilities you still want to own and which responsibilities you want the cloud provider to manage. More managed does not automatically mean better, but it can reduce operational work when the trade-off fits the application.

Availability is another reason cloud architecture looks different from running one machine in one room. Cloud providers divide infrastructure into regions and availability zones so applications can be designed to avoid depending completely on one location. That does not make failures disappear, but it gives you building blocks for designing systems that can continue operating when individual components or locations have problems.

The same idea applies to storage. Instead of thinking only in terms of a hard drive attached to one machine, cloud platforms give you object storage, block storage, managed databases, distributed caches, and other options. The important skill is not memorizing every storage service. It is understanding what kind of data you have, how it needs to be accessed, how durable it needs to be, and what happens if the compute running your application gets replaced.

Security also changes in the cloud because the infrastructure is programmable. Permissions, network rules, encryption, identity, logging, and access controls can all be defined through configuration. That creates a lot of flexibility, but it also means bad configuration can be just as dangerous as bad code. A powerful cloud account with overly broad permissions can create a much bigger problem than a small local project.

This is why I do not think learning cloud computing should start with memorizing service names. I would first understand compute, networking, storage, databases, identity, availability, monitoring, and cost. Once those ideas make sense, services like EC2, S3, RDS, IAM, CloudWatch, and Lambda stop feeling like random products and start looking like different ways to solve familiar infrastructure problems.

The biggest shift for me was realizing that cloud computing is not mainly about where the computer is located. It is about how infrastructure is provisioned, managed, scaled, automated, and replaced. The remote server is only one part of that.

If someone asked you to explain cloud computing without using the phrase “someone else’s computer,” how would you explain it?


r/CloudandCode • • Jun 24 '26

A beginner tech portfolio that actually looks useful

44 Upvotes

Most beginner portfolios are just a list of links.

GitHub link.

Project title.

Maybe a screenshot.

Then nothing else.

That is better than having no portfolio, but it does not tell someone much.

A good portfolio should not just show that you completed projects.

It should show how you think.

That matters because anyone can follow a tutorial.

Not everyone can explain what they built, why they built it, and how the pieces work together.

If you are learning Python, AWS, SQL, cloud, or data, your portfolio does not need to be fancy.

It needs to be clear.

Here is what I would include.

  1. A short intro

Keep it simple.

Who you are.

What you are learning.

What kind of roles or projects you are interested in.

You do not need a dramatic story.

Something like:

“I’m learning Python and cloud by building practical projects around automation, APIs, databases, and AWS.”

That is enough.

  1. Three solid projects

You do not need 20 random projects.

Three well-explained projects are better than 20 copied ones.

Pick projects that show different skills.

For example:

One Python automation project.

One database or SQL project.

One cloud deployment project.

This shows range without making your portfolio messy.

  1. A clear project description

For each project, explain what it does in plain English.

Not just:

“Built a weather app.”

Say:

“Built a Python app that takes a city name, calls a live weather API, handles errors, and displays current weather data.”

That sounds much more useful.

  1. The problem it solves

This is the part most beginners skip.

Every project should answer:

Why does this exist?

A file organiser solves messy folders.

An expense tracker solves personal spending visibility.

A cloud cost reporter helps monitor AWS usage.

A portfolio project becomes stronger when it solves a real problem, even a small one.

  1. Tools used

Mention the tools clearly.

Python.

Flask.

SQLite.

pandas.

boto3.

AWS S3.

EC2.

RDS.

GitHub.

Whatever you used, list it.

This helps someone quickly understand what skills the project demonstrates.

  1. Screenshots

Screenshots make the project feel real.

A terminal output is fine.

A dashboard screenshot is better.

A deployed app screenshot is even better.

People should be able to understand the project without opening the code immediately.

  1. A clean README

Your README is more important than most beginners think.

A good README should explain:

What the project does.

Why you built it.

How to run it.

What tools it uses.

What features it has.

What you learned.

What you would improve.

A weak README makes even a good project look unfinished.

  1. What you learned

This is where you show growth.

Do not write generic lines like:

“I learned Python.”

Be specific.

For example:

“I learned how to handle API errors when the response is missing expected data.”

Or:

“I learned how IAM permissions affect access between AWS services.”

Specific learning looks much more believable.

  1. What you would improve

This is a small thing that makes your portfolio look more mature.

Every project has limitations.

Mention them.

Maybe you would add authentication.

Maybe you would improve error handling.

Maybe you would deploy it properly.

Maybe you would add tests.

This shows that you can think beyond the first version.

  1. A simple structure

Do not make the portfolio hard to navigate.

Use a clean layout.

About.

Skills.

Projects.

GitHub.

Contact.

That is enough.

The goal is not to impress people with design.

The goal is to make your work easy to understand.

A useful beginner portfolio says:

Here is what I built.

Here is why I built it.

Here is how it works.

Here is what I learned.

Here is what I would improve.

That is much stronger than just saying:

“I completed a course.”

Courses are useful.

Certifications are useful.

But a portfolio gives proof.

It shows that you can build something, explain it, and improve it.

That is what makes it valuable.

If you are a beginner, do not wait until you feel “job-ready” to build a portfolio.

Build it while you learn.

Your first version will not be perfect.

That is fine.

A portfolio is not just a final showcase.

It is a record of how your skills are growing.

Drop your current skill path below and I’ll suggest 2 portfolio project ideas you can build.


r/CloudandCode • • Sep 17 '26

Python Python Project #3: Build an expense tracker that is actually worth putting on GitHub

17 Upvotes

A lot of beginner Python projects technically work, but they do not really teach you much beyond syntax. You follow a tutorial, copy the code, run it once, and move on. I think a better project is one that starts simple, then forces you to make decisions as you improve it. An expense tracker is a good example because the first version is easy enough for a beginner, but there are plenty of ways to make it more realistic over time.

I would start with the smallest possible version. Ask the user for an expense amount, category, date, and short description, then save the data into a CSV file. At this stage, you are already practising input handling, functions, working with files, basic data structures, and thinking about how information should be stored. The goal is not to build a perfect finance app on day one. The goal is to get one complete flow working from input to storage.

Once that works, I would add the ability to actually read the data back. Let the user view all expenses, filter them by category, or see only expenses from a specific month. This is where the project starts becoming more interesting because you are no longer just writing data into a file. You now have to load it, parse it correctly, filter it, handle dates, and display the results in a way that someone can actually understand.

Then I would add monthly summaries. Instead of showing twenty individual transactions, calculate how much was spent in total and how that spending is distributed across categories. You could show something like rent, food, transport, subscriptions, and other expenses. At this point, you start practising aggregation and simple data analysis, which makes the project useful for someone learning Python for automation or data work as well.

The next improvement I would make is input validation. What happens if someone types abc when the program expects an amount? What happens if the date is invalid? What happens if the category is empty or the CSV file does not exist yet? A project becomes much more realistic when you stop assuming the user will always provide perfect input. Handling these situations properly teaches you more than adding another random feature.

I would also think about duplicate and editing behaviour. Maybe a user enters the same expense twice by mistake. Maybe they entered the wrong amount and need to update it. Maybe they want to delete an old record. These features force you to think about how individual records are identified and how changes should be applied safely instead of simply appending new rows forever.

Once the basic version feels solid, I would improve the structure of the code. If everything is inside one giant main() function, split the responsibilities into smaller pieces. One function might add an expense, another might load expenses, another might filter them, and another might generate summaries. This is where you start learning why code organization matters, because the project becomes easier to change when every feature is not tightly connected to everything else.

You can also introduce a simple configuration system instead of hard coding everything. For example, maybe the user can define their own categories or set a monthly budget. Then the program could compare current spending with that budget and show how much is left. That makes the application feel less like a coding exercise and more like something another person could actually use.

After that, I would add one simple visualization. You do not need ten charts. A basic monthly spending chart or a category breakdown is enough. The interesting part is not making something colorful. The interesting part is taking the data your own application collected, summarizing it, and turning it into something easier to understand.

At this point, you could also decide whether CSV is still the right storage option. For the first version, CSV is perfect because it is simple and forces you to understand file handling. Later, you could move the same project to SQLite and learn how persistent application data changes when you start using a real database. That upgrade alone can turn the project into a good bridge between beginner Python and SQL.

I would not add a GUI immediately. First make sure the actual application logic works. Once the command line version is reliable, you could add a small Tkinter interface, a Flask or FastAPI backend, or even keep it as a CLI tool and improve the user experience there. The important thing is that the interface should sit on top of working logic rather than hiding poorly structured code behind buttons.

The GitHub repository matters too. I would include a README that explains what the project does, what problem it solves, how to run it, what features are included, and what you learned while building it. Add a sample screenshot or terminal output, keep the requirements clear, and make sure someone can clone the repository and actually get it running. That makes the project much easier to evaluate than a repository containing only expense_tracker.py.

The bigger lesson here is that a good beginner project does not need to be original or complicated. An expense tracker has been built thousands of times, and that is fine. What matters is whether you actually understand the decisions inside your version. If someone asks why you chose CSV first, how you handled invalid input, how you structured your functions, or why you later moved to SQLite, you should be able to explain it.

That is what makes the project worth putting on GitHub. Not the fact that it has twenty features, but the fact that you built something in stages, ran into problems, made decisions, improved the design, and can explain how the application evolved. I would much rather see that from a beginner than another huge project copied line by line from a tutorial.

If I were building this from zero, my progression would basically be: get one expense saved correctly, make the data searchable, add useful summaries, handle bad input, improve the structure, then add storage or interface upgrades only when the current version actually needs them. Each stage should teach you something new instead of just making the feature list longer.

If you built this project, what would you add first after the basic CSV version: budget tracking, charts, SQLite, or a simple GUI?


r/CloudandCode • • Oct 10 '26

Guide Case Study: I built the same Python API three ways, Flask vs FastAPI vs Django

18 Upvotes

Clarification: this is a conceptual walkthrough of the same task API in three frameworks. It does not report three completed implementations or measured benchmark results. Reddit does not let me change the original title, so I’m making that distinction explicit here.

I’d choose a framework by the work around the endpoints: validation, database access, authentication, administration and maintenance. Here is how I would reason about Flask, FastAPI and Django for one small application.

Keep the requirements the same

Imagine a task API backed by PostgreSQL. A task has an ID, title, description, completion status and creation date.

The routes would be:

  • POST /tasks: create a task.

  • GET /tasks: list tasks.

  • GET /tasks/{id}: fetch one task.

  • PATCH /tasks/{id}: change selected fields.

  • DELETE /tasks/{id}: remove a task.

I’d also require input validation, predictable errors, database migrations, tests, configuration outside the code and clear setup instructions. If users are added, each user should only access tasks they are allowed to see.

Keeping that contract fixed makes the comparison useful. A different endpoint spelling tells me little about how a framework handles the rest of the application.

Flask: choose the pieces yourself

Flask gives me a lightweight starting point for routing requests to Python functions. For a small internal API, that can be easy to follow: I can see the request arrive, run the application logic and return a response.

As the project grows, I would need to choose more of the surrounding stack. That includes validation, database integration, serialization, migrations, authentication and a project structure. Flask’s extension ecosystem supports adding functionality as the application needs it.

That flexibility suits a project where I already know which components I want. I can keep a small service focused, choose my database layer and avoid introducing features I do not need.

The trade-off is decision-making. A beginner may spend as much time comparing libraries as learning the request flow. A team also needs conventions so every route does not handle validation and errors differently.

For this task API, I’d settle on one validation approach, one database access pattern and one error format early. Then I would test an invalid title and a missing task before adding more endpoints.

FastAPI: make the API contract explicit

For a standalone API, I like having request and response shapes close to the endpoint definition. FastAPI combines Python typing with validation models and generated API documentation. Its features documentation explains those built-in API tools.

For POST /tasks, I would define which fields are accepted, whether a title can be empty and which fields the response exposes. For PATCH, I would distinguish an omitted field from a field explicitly supplied with a value.

That gives another developer a clearer contract. Interactive documentation also makes it easier to inspect the available requests while developing, although I would still document setup, authentication and examples in the README.

FastAPI does not remove database design or application decisions. I still need migrations, transactions, authorization, dependency choices and a maintainable layout.

I would also choose synchronous or asynchronous code according to the libraries doing the work. Adding async to a function does not make a blocking database or HTTP call non-blocking. The official async guidance is useful before mixing those styles.

For this API, I’d start with a consistent database approach and test it under a realistic workload before making performance claims. Clear validation and documentation are useful even without a benchmark win.

Django plus DRF: consider the whole product

For an API comparison, I would consider Django together with Django REST Framework. Django brings a larger application foundation, including its ORM, migrations, authentication system and admin interface. DRF adds API-focused tools such as serializers and permissions.

That is more structure to learn for five CRUD endpoints. It becomes easier to justify if the application also needs user accounts, staff administration, related data models or an established way to organize a larger codebase.

Imagine the task app gaining organizations, memberships, role-based access and an internal support team. An admin interface and consistent model/migration workflow could save substantial custom work.

I would still test access deliberately. Authentication identifies a caller; authorization decides what that caller can do. Adding a framework or a permission class does not automatically prove that every query and object operation respects task ownership.

The question I’d ask is which Django features the product will actually use. Endpoint count alone would not decide it for me.

What I would choose for this example

  • A small service with specific library choices and limited surrounding features: I’d consider Flask.

  • A standalone API where explicit schemas, validation and interactive docs matter: I’d consider FastAPI.

  • A product with relational models, administration, accounts and growing application workflows: I’d consider Django with DRF.

These are starting points for a decision. Existing team knowledge, integrations, deployment constraints and maintenance requirements can change the answer.

Test the same behavior in every version

I’d write the acceptance checks before comparing frameworks:

  1. A valid create request returns a task that can be fetched later.

  2. Invalid input returns a useful error without saving a bad record.

  3. Fetching or changing a missing task behaves consistently.

  4. If the app has users, one user cannot access another user’s private tasks.

  5. A database failure produces useful logs without exposing credentials.

  6. Another developer can run the app and migrations from the README.

If performance matters, I’d measure the same workload, database state and deployment resources. Slow queries, external requests and configuration deserve investigation alongside framework overhead.

A useful next exercise

I’d learn one framework well enough to build, test and deploy this complete API. Then I would implement one endpoint in a second framework and compare the validation, database call, error handling and tests.

The Project Library has small builds to start with. Bring a specific framework decision or blocker to the Project Clinic.

For your next backend, which requirement would have the biggest effect on the choice: API contracts, administration, existing team experience or something else?


r/CloudandCode • • Aug 12 '26

AWS & Cloud 10 AWS services you should actually understand as a beginner

23 Upvotes

AWS feels overwhelming when you first start because there are so many services. You open the console, see names like EC2, Lambda, DynamoDB, Route 53, CloudFront, ECS, SQS, SNS, and dozens more, and it is easy to assume that becoming good at AWS means learning as many of them as possible.

I don’t think that is the best way to start.

You do not need to memorize hundreds of AWS services before you can build something useful. I would rather understand a small group of core services properly, know what problem each one solves, and understand how they connect inside a real architecture.

If I were learning AWS again from zero, these are the 10 services I would focus on first.

1. IAM

I would start with IAM because permissions appear almost everywhere in AWS. IAM controls who or what can access AWS resources and what actions they are allowed to perform.

For example, imagine a Lambda function needs to read an image from S3. The function does not automatically get access just because both services belong to the same AWS account. Its execution role needs permission to perform the required S3 action on the correct resource.

That is the important idea behind IAM. You should be able to answer three questions: who is requesting access, what action are they trying to perform, and which resource should they be allowed to access?

This is also where you should learn least privilege. Giving AdministratorAccess to everything may make permission errors disappear, but it does not teach you how AWS security actually works. Give users and services only the permissions they genuinely need.

2. EC2

EC2 is one of the best services for understanding what a server in the cloud actually is.

You launch a virtual machine, choose an operating system, connect to it using SSH, install software, configure ports, and run an application. A single EC2 project can introduce you to Linux, networking, security groups, deployment, public IP addresses, and basic server management.

For example, you could launch an EC2 instance, install Nginx or Apache, deploy a simple application, and make it accessible through the internet.

EC2 also teaches an important cloud lesson: more control usually means more responsibility. AWS provides the underlying infrastructure, but you still have to think about the operating system, application configuration, security, updates, and monitoring.

3. S3

S3 is usually introduced as AWS storage, but I think beginners should understand it as object storage rather than simply "a folder in the cloud."

S3 can store images, videos, backups, reports, logs, static website files, application assets, datasets, and many other types of objects. You should learn buckets, objects, permissions, versioning, storage classes, lifecycle rules, and the difference between public and private access.

S3 also becomes more useful when you stop learning it in isolation.

A user might upload an image to S3. That upload could trigger Lambda. Lambda could process the image and store the result back in S3. CloudFront could later deliver that image efficiently to users.

That is when AWS starts becoming easier to understand. You stop seeing individual services and start seeing workflows.

4. VPC

VPC is probably where AWS starts feeling genuinely confusing for a lot of beginners.

At a simple level, a VPC is the network where many of your AWS resources live. Inside it, you start working with subnets, route tables, internet gateways, security groups, NAT gateways, IP addresses, and public versus private resources.

You do not need advanced networking knowledge before touching AWS, but you should understand the basic idea of how traffic reaches a resource.

Imagine you have an application running on EC2 and a database running on RDS. Your users need to reach the application from the internet, but they probably should not be able to connect directly to your database.

That one requirement already teaches you why some resources should be public and others should remain private.

Once that idea clicks, VPC diagrams become much less intimidating.

5. RDS

Most real applications need to store structured data somewhere. Users, products, orders, payments, posts, and transactions usually need a database.

RDS gives you managed relational databases without requiring you to manually install and manage everything on an EC2 instance. You can work with engines such as PostgreSQL or MySQL while AWS manages a lot of the underlying database infrastructure.

As a beginner, I would focus on understanding how applications connect to RDS, backups, availability, database security, and why the database usually should not be publicly exposed.

Imagine an application running on EC2 that stores user information in RDS. Now you have to think about networking, security groups, credentials, and which resources are allowed to communicate.

One project suddenly connects EC2, RDS, VPC, and security together.

6. Lambda

Lambda teaches a completely different way of thinking about compute.

Instead of launching a server and keeping it running, you write a function and AWS executes it when something happens. That event could be an API request, an S3 upload, a scheduled task, or another AWS service.

For example, a user uploads an image to S3. The upload triggers a Lambda function. Lambda resizes the image and stores the smaller version back in S3.

That small project teaches serverless computing, event-driven architecture, IAM permissions, logs, triggers, and service integration.

But I would also learn when Lambda is not the right choice. Execution duration, memory requirements, workload characteristics, dependencies, and the amount of control you need can all affect the decision.

Understanding a service also means understanding when not to use it.

7. DynamoDB

After learning RDS, I would look at DynamoDB because it introduces a different database model.

DynamoDB is a managed NoSQL database built for workloads where predictable performance and large-scale access are important. You do not manage traditional database servers in the same way you would with relational databases.

The most useful beginner lesson is not memorizing DynamoDB terminology. It is understanding that database design depends heavily on how your application needs to access its data.

With RDS, you naturally think about tables, relationships, joins, and SQL. With DynamoDB, access patterns become much more important early in the design.

A simple serverless project using API Gateway, Lambda, and DynamoDB is a great way to understand how these services work together.

8. CloudWatch

CloudWatch is one of the services beginners often ignore until something stops working.

Then it suddenly becomes extremely important.

CloudWatch gives you logs, metrics, alarms, and monitoring for AWS resources. If a Lambda function fails, CloudWatch logs can help show what happened. If an EC2 instance is consuming unusually high CPU, CloudWatch metrics can make that visible. If you want to know when something crosses a threshold, you can create an alarm.

Building an application is only half the job. Once the application is running, you need some way to understand what it is doing.

I would get into the habit of checking logs early rather than treating monitoring as an advanced topic.

9. Elastic Load Balancing

EC2 makes sense when you have one server. Load balancing starts making sense when you have more than one.

Imagine your application grows and a single EC2 instance is no longer enough. You launch several instances to handle the traffic. Now users need a single place to send their requests rather than knowing which individual server to contact.

An Elastic Load Balancer can receive incoming traffic and distribute it across multiple healthy targets.

This is where beginners start moving from thinking about a server to thinking about an architecture.

When you combine load balancing with Auto Scaling, you also start understanding ideas such as horizontal scaling, high availability, health checks, and handling changing demand.

10. Route 53

Route 53 introduces DNS and helps connect human-friendly domain names to your AWS infrastructure.

Instead of asking users to visit an EC2 IP address, you can use something like example.com. Route 53 can route that domain toward resources such as a load balancer or CloudFront distribution.

Learning Route 53 is also a good reason to understand DNS outside AWS. What actually happens after someone types a domain into their browser? How does that domain eventually lead to your application?

Once you understand that flow, Route 53 becomes much easier than simply memorizing record types.

The important part of learning these 10 services is not being able to define each one in an interview.

It is being able to understand how they fit together.

Imagine a normal web application. Route 53 helps users find the application. A load balancer receives the traffic and distributes it across EC2 instances. Those instances run inside a VPC. RDS stores structured application data, while S3 stores files. IAM controls access between resources, and CloudWatch helps you understand what the system is doing.

A different application might replace EC2 with Lambda and RDS with DynamoDB.

Neither architecture is automatically better.

The services change because the requirements change.

That is the point where AWS started making more sense to me. Instead of asking, “What does this service do?”, you start asking, “What problem in my architecture does this service solve?”

If I had to learn these in a rough order, I would go with IAM, EC2, S3, VPC, RDS, Lambda, DynamoDB, CloudWatch, Elastic Load Balancing, and Route 53.

But I would not wait until I had mastered all ten before building anything. Learn enough to understand the basic idea, build something small, see where the service fits, and then connect it with the next service.

AWS becomes much easier when services stop being names you memorize and start becoming tools you choose for a reason.

Which of these 10 services made sense in theory but became confusing when you actually tried to use it?


r/CloudandCode • • Aug 27 '26

Python If I had to learn Python from zero again, this is the order I'd follow

111 Upvotes

A lot of Python roadmaps become huge checklists.

Learn syntax, then OOP, then Django, then data science, then machine learning, then somehow Docker gets thrown in.

I think that makes Python feel much harder than it actually is.

I'd learn it in layers.

1. Get comfortable with the language first

Start with variables, strings, numbers, lists, dictionaries, conditions, loops, functions, and basic input/output.

Don't spend weeks trying to memorize syntax.

Learn a concept, use it, break something, fix it.

At this stage, a calculator, guessing game, expense tracker, or simple CLI app is completely fine. You're just training yourself to turn logic into code.

2. Learn how Python handles real files and data

Once basic syntax stops feeling strange, move into file handling, exceptions, modules, packages, comprehensions, JSON, CSV, and virtual environments.

This is where Python starts becoming genuinely useful.

Build a file organizer. Parse a CSV. Rename hundreds of files automatically. Pull some data from an API and save it locally.

Those small projects teach more than another five hours of syntax videos.

3. Learn APIs and databases

This is one of the points where beginner projects start turning into actual applications.

Learn HTTP basics, requests, JSON responses, CRUD operations, SQL, and a database like SQLite or PostgreSQL.

For example, build an app that:

fetches data from an API
→ processes it
→ stores it in a database
→ lets you query it later

Now you're combining multiple skills instead of practicing them in isolation.

4. Learn enough OOP to understand real code

Classes, objects, methods, inheritance, composition.

You should understand these concepts, but I wouldn't make OOP the center of your Python learning.

A lot of beginners end up creating classes for things that would have been perfectly fine as a few functions.

Learn when OOP improves structure, not just how to write class Something:.

5. Learn Git and project structure earlier than most roadmaps suggest

Once your project has more than a couple of files, learn Git and GitHub properly.

Also learn how to separate your code into modules, manage dependencies, use environment variables, and keep configuration outside your source code.

Your goal should eventually be to move from one giant file to something another developer could open and understand without needing an explanation from you first.

6. Pick a direction

There's no single version of "advanced Python."

Advanced for a backend engineer looks very different from advanced for someone doing data analysis.

If you want backend development, learn FastAPI or Django, databases, authentication, caching, background jobs, and deployment.

If you want automation, go deeper into APIs, browser automation, scheduling, Linux, and scripting.

If you want data, learn NumPy, pandas, SQL, visualization, and then ML if your work actually requires it.

If you want cloud or DevOps, Python becomes useful for SDKs, APIs, automation, infrastructure tooling, and operational scripts.

Pick one path instead of trying to learn all of them.

7. Start testing your code

Learn pytest, assertions, logging, debugging, exception handling, and basic mocking.

This is a useful turning point.

Beginners usually ask:

More experienced developers eventually start asking:

Take an old project and add tests instead of immediately starting another project.

8. Learn production concepts when your projects need them

Then start exploring things like type hints, async programming, concurrency, authentication, security, caching, Docker, CI/CD, packaging, monitoring, and deployment.

But don't treat this as another checklist.

If your application has no performance problem, you probably don't need to study five caching strategies yet.

Learn these concepts when you understand the problem they're solving.

9. Stop building endless beginner projects

This is probably one of the biggest upgrades you can make.

Instead of building:

calculator
todo app
weather app
quiz app
another calculator

Take one project and keep extending it.

A simple task manager can become:

CLI
→ database
→ REST API
→ authentication
→ tests
→ logging
→ Docker
→ deployment

Same project, completely different level of learning.

10. Read code you didn't write

Eventually, tutorials stop being enough.

Read open-source projects. Look through libraries you already use. Read pull requests. Debug someone else's code. Try making a small contribution.

Advanced Python isn't really about knowing obscure syntax.

It's being able to enter an unfamiliar codebase, understand what's happening, make a change without breaking everything, and explain why you made that decision.

So the roadmap I'd follow is roughly:

Python basics → files & data → APIs → SQL → Git → larger projects → testing → specialization → production concepts → real codebases

Don't worry too much about when you officially become "advanced."

If you can build something useful, debug it, test it, explain your design decisions, and improve it months later without wanting to rewrite everything from scratch, you're doing pretty well.

I've been organizing our Python roadmap and project resources around this same progression too, mainly for people who prefer having the learning path and projects structured in one place.

For people who already know Python, where did you feel the biggest jump happened: learning the syntax, building real projects, or maintaining larger codebases?


r/CloudandCode • • Jun 23 '26 Snek

If AWS feels hard, learn these basics first

33 Upvotes

A lot of beginners think AWS is hard because AWS has too many services.

That is partly true.

But I think there is another reason.

AWS feels hard because it combines multiple fundamentals at the same time.

Servers.

Networking.

Security.

Storage.

Databases.

Monitoring.

Pricing.

Deployment.

So when a beginner opens AWS and sees EC2, VPC, IAM, S3, RDS, Lambda, CloudWatch, Route 53, and 200 more services, it feels impossible to know where to start.

The problem is usually not AWS.

The problem is that the foundation is missing.

Before AWS, I would learn these basics first.

  1. How websites work

You should understand what happens when someone opens a website.

The simple version is:

User enters a URL.

DNS finds the server.

The browser sends a request.

The server returns a response.

The browser displays the page.

This makes services like Route 53, EC2, Load Balancers, and CloudFront much easier to understand.

  1. Basic networking

You do not need to become a network engineer.

But you should understand the basics.

IP addresses.

Ports.

DNS.

Public networks.

Private networks.

Firewalls.

Subnets.

Traffic rules.

This matters because AWS networking shows up everywhere.

VPC is networking.

Security Groups are networking.

Subnets are networking.

Internet Gateways are networking.

NAT Gateways are networking.

If networking is confusing, AWS will feel confusing too.

  1. Linux basics

Most cloud servers run on Linux.

So you should be comfortable using a terminal.

Learn how to move around folders, create files, install packages, check running processes, read logs, and run basic commands.

This makes EC2 much easier.

Without Linux basics, launching an EC2 instance feels like clicking buttons without knowing what happens next.

  1. Database basics

Most real applications need to store data.

Users.

Orders.

Posts.

Payments.

Logs.

Reports.

Settings.

Before learning RDS or DynamoDB, understand what a database does.

Learn tables, rows, columns, primary keys, queries, and basic relationships.

You do not need to master database design immediately.

But you should understand why applications need databases in the first place.

  1. Security basics

AWS security starts with one simple question:

Who should be allowed to do what?

That is why IAM matters.

Before going deep into IAM policies, understand users, permissions, roles, least privilege, and access keys.

A common beginner mistake is giving everything full access because it makes errors disappear.

That is also how bad security habits start.

  1. Logs and monitoring

Building something is not enough.

You also need to know what is happening inside it.

Did the app crash?

Did the request fail?

Did the server run out of CPU?

Did the Lambda function throw an error?

Did the cost suddenly increase?

This is why services like CloudWatch matter.

Monitoring is not advanced.

It is part of running real systems.

  1. Cost awareness

Cloud is not free just because it is easy to start.

Before building on AWS, understand the basics of pricing.

Pay as you go.

Free tier limits.

Storage costs.

Data transfer.

Running instances.

Managed services.

Leaving resources active.

This one skill can save beginners a lot of stress.

Once these basics are clear, AWS becomes much easier.

EC2 makes sense because you understand servers.

VPC makes sense because you understand networking.

IAM makes sense because you understand permissions.

S3 makes sense because you understand storage.

RDS makes sense because you understand databases.

CloudWatch makes sense because you understand logs.

Billing makes sense because you understand usage.

That is why I do not think beginners should start AWS by memorizing every service.

Start by understanding the ideas behind the services.

Then the services become tools instead of random names.

If AWS feels confusing right now, it might not mean you are bad at cloud.

It might just mean you need to strengthen the basics first.

If people want, I can make a simple “before AWS” roadmap for complete beginners.


r/CloudandCode • • Jun 30 '26

5 AWS projects that teach cloud better than memorizing services

39 Upvotes

A lot of beginners try to learn AWS by memorizing service names.

EC2.

S3.

IAM.

VPC.

Lambda.

RDS.

CloudWatch.

That is useful at the beginning, but it only gets you so far.

At some point, you need to understand how these services work together.

That is where projects help.

Not huge production systems.

Not complicated architecture diagrams.

Small projects that teach one or two real cloud concepts clearly.

Here are five AWS projects that actually teach useful cloud skills.

  1. Static website using S3 and CloudFront

Build a simple personal website and host it on S3.

Then put CloudFront in front of it.

This teaches object storage, static hosting, CDN basics, public access, caching, and how websites are delivered globally.

It also gives you a simple deployed project you can show.

This is much better than only reading what S3 does.

You actually see how storage becomes a website.

  1. EC2-hosted portfolio site

Launch an EC2 instance and deploy a basic portfolio or landing page on it.

This teaches servers, SSH, Linux basics, security groups, ports, package installation, and basic deployment.

It also helps you understand what “running code on a server” actually means.

A lot of cloud concepts become clearer once you have connected to a server yourself and deployed something manually.

  1. Serverless contact form with Lambda

Build a simple contact form that sends data to a Lambda function.

The Lambda function can process the message and store it or send a notification.

This teaches serverless computing, event-driven architecture, API Gateway, Lambda triggers, permissions, and error handling.

It also shows you that not every backend needs a full server.

For beginners, this is one of the best ways to understand why serverless exists.

  1. File upload system using S3

Build a small app where users can upload files to S3.

Start simple.

Upload a file.

Store it in a bucket.

Return the file URL.

Then improve it later with private access, pre-signed URLs, file type checks, or lifecycle rules.

This teaches buckets, permissions, object storage, IAM, and secure file handling.

This matters because file uploads are used everywhere.

Profile pictures, invoices, reports, PDFs, backups, and media files all need storage.

  1. AWS billing alert using Budgets and SNS

Create a simple billing alert that sends a notification when your AWS cost crosses a limit.

This is not the flashiest project, but it is one of the most practical.

It teaches cost awareness, AWS Budgets, SNS notifications, alerts, and basic cloud responsibility.

Beginners often ignore cost until something goes wrong.

This project teaches you to think like someone who is actually running cloud resources.

The pattern across all five projects is simple:

They use real AWS services.

They solve a real problem.

They teach how services connect.

They give you something you can explain.

That is what makes a cloud project useful.

Not how many services it uses.

Not how complex the diagram looks.

A good beginner AWS project should help you answer questions like:

Where is the app running?

Where is the data stored?

Who has permission to access it?

How does traffic reach it?

How do I monitor it?

What could increase the cost?

What would I improve next?

Those questions matter more than memorizing 30 service names.

AWS starts making sense when you stop seeing services as separate flashcards and start seeing them as parts of a system.

That is the real value of building projects.

You learn what each service does by using it for a reason.

If people want, I can break one of these AWS projects down into a step-by-step beginner plan.


r/CloudandCode • • Jun 21 '26

Most beginners don’t need more tech tutorials. They need better projects.

70 Upvotes

A lot of beginners are stuck in the same loop.

They watch a tutorial.

They copy the code.

They feel like they understood it.

Then a few days later, they try to build something on their own and completely freeze.

I don’t think the problem is that beginners are lazy.

The problem is that tutorials usually show the clean path.

Real projects do not.

A tutorial tells you what to type next.

A project forces you to decide what should happen next.

That difference matters.

If you are learning Python, AWS, SQL, cloud, or almost any tech skill, there comes a point where watching more videos gives you less return.

You need to build something that makes you think.

Not a huge project.

Not a fake startup.

Not a “build Netflix from scratch” project.

Just something small that solves a real problem.

For example:

A calculator app is fine for syntax.

But a weather app using a live API teaches HTTP requests, JSON, API errors, user input, and how real systems exchange data.

A basic to-do app is fine for CRUD practice.

But an expense tracker with a database teaches data storage, filtering, updates, reports, and how applications actually remember information.

A simple Python loop teaches repetition.

But a file organiser teaches working with folders, messy files, edge cases, automation, and mistakes that happen in real life.

That is the difference.

A good beginner project should teach transferable skills.

Things like:

Files
APIs
Databases
Authentication
Cloud deployment
Automation
Error handling
User input
Logging
Clean documentation

You do not need 50 projects.

You need a few projects that force you to ask better questions.

Why did this break?

How do I handle bad input?

Where should this data be stored?

What happens if the API fails?

How would someone else run this project?

How do I explain this clearly in a README?

Those questions are where the real learning happens.

Most beginners think they are stuck because they need another course.

A lot of the time, they just need a better project.

Something small enough to finish, but useful enough to teach real skills.

That is what makes projects valuable.

They expose the gaps tutorials hide.

So instead of asking:

“What tutorial should I watch next?”

Ask:

“What can I build with what I already know?”

That one question changes the way you learn.

If people want, I can share a list of beginner project ideas for Python, AWS, SQL, and cloud that actually teach useful skills.