AWS Builder Center
From Writing Code to Building in the Cloud: My First Steps with AWS

From Writing Code to Building in the Cloud: My First Steps with AWS

Starting my AWS journey as a Computer Science undergraduate and discovering how cloud computing is changing the way I think about software development, architecture, security, and real-world applications.

As a Computer Science undergraduate, I spent most of my early years learning how to write code, design algorithms, work with local databases, and solve software engineering problems.
For a long time, my mental model of software development was straightforward:
Write the code β†’ connect the database β†’ test the application β†’ finish the project.
However, as I started working on larger applications, critical questions began to emerge:
  • Where does the application actually run once it leaves my machine?
  • How does it handle hundreds or thousands of concurrent users?
  • Where should user-uploaded files be stored safely?
  • How do different services communicate securely?
  • How do we monitor system health and recover when something fails?
These questions shifted my focus from single-machine development to a much broader field: Cloud Computing. That is where my AWS journey began.

☁️ The First Time I Looked at AWS

When I first opened the AWS Management Console, I felt completely overwhelmed. Seeing dozens of categories - compute, storage, databases, networking, security, machine learning - felt like looking at an endless encyclopedia of enterprise tools.
I kept running into service names like:
  • Amazon EC2 & AWS Lambda (Compute)
  • Amazon S3 (Object Storage)
  • Amazon RDS & Amazon DynamoDB (Databases)
  • AWS IAM & Amazon VPC (Security & Networking)
  • Amazon CloudFront & Amazon CloudWatch (Content Delivery & Monitoring)
At first, I thought: β€œDo I need to master all of these before I can build anything?”
The realization that changed everything was simple: No. You don't need to memorize AWS services. You need to understand specific problems, evaluate potential solutions, and select the tool that best fits the scenario.

🧩 AWS Started Making Sense When I Started Thinking About Problems

Instead of beginning with:
  • β€œWhich AWS services should I learn?”
I started asking:
  • β€œWhat does my application need?”
For example, if my application needs to store images or documents, I can explore Amazon S3.
If I need a virtual server to run an application, I can explore Amazon EC2.
If I need a relational database, I can explore Amazon RDS.
If I want to run backend code without managing a traditional server, I can explore AWS Lambda.
This way of thinking made AWS feel less like a huge collection of unrelated services and more like a toolbox.

My simple rule became:

  • Start with a problem.
  • Understand the requirements.
  • Find possible solutions.
  • Learn the AWS service that fits.
  • Build something.
  • Test it.
  • Improve it.
That approach feels much more natural to me as a developer.

πŸ› οΈ Learn β†’ Build β†’ Break β†’ Understand β†’ Improve

Because I'm still learning AWS, I don't want my learning to be limited to watching tutorials or reading documentation.
I want to build things.
My current learning cycle is:
Learn β†’ Build β†’ Break β†’ Understand β†’ Improve

1. Learn

First, I understand the basic concept.
For example:
What is Amazon S3 and why would I use it?

2. Build

Then I create a small experiment.
For example:
  • Create an S3 bucket.
  • Upload an object.
  • Retrieve the object.
  • Connect it to a small application.

3. Break

Something will probably go wrong.
Maybe:
  • A permission is incorrect.
  • A configuration is wrong.
  • A service can't communicate with another resource.
  • Something doesn't behave as expected.
And that's okay.

4. Understand

Instead of immediately copying a solution, I try to understand:
Why did it fail?

5. Improve

After understanding the problem, I fix it and improve the implementation.
This makes mistakes part of the learning process rather than something to avoid.

πŸ” One of My Biggest Lessons: Security Matters

Another important lesson I've started learning is that making an application work isn't enough.
It also needs to be secure.
AWS Identity and Access Management (IAM) made me think more carefully about permissions and access.
One simple question can lead to many important decisions:
  • Who should have access to this resource?
For example:
  • Does every user need the same permissions?
  • Does every application component need access to the database?
  • Should a service be allowed to modify a resource?
  • Can access be restricted to only what is required?
This introduced me to an important security principle:
Give users and services only the permissions they actually need.
I'm still learning the deeper aspects of cloud security, but this is already changing how I think about application design.

πŸ’° Cloud Made Me More Aware of Resources and Cost

Another thing I am learning is that cloud resources need to be managed responsibly.
When I develop locally, I can start an application and usually don't think about infrastructure costs.
With cloud resources, I need to be more careful.
When experimenting, I want to develop habits such as:
  • Understanding what resource I'm creating.
  • Checking how the resource is priced.
  • Monitoring my usage.
  • Understanding available free usage or credits.
  • Removing resources I no longer need.
  • Checking the AWS billing and cost-management information regularly.
For me, this is an important part of becoming a responsible cloud developer.
Learning AWS isn't only about learning technology.
It is also about learning how to manage that technology responsibly.

πŸš€ Connecting AWS With My Development Skills

I don't want AWS to be something completely separate from my existing software development knowledge.
I want to connect cloud technologies with the applications I already know how to build.
For example, imagine a web application:
Frontend β†’ Backend β†’ Database
Once I start thinking about deploying it to the cloud, many more questions appear:
  • Where should the frontend run?
  • Where should the backend run?
  • Where should uploaded files be stored?
  • Which database should be used?
  • How should users authenticate?
  • How should permissions be managed?
  • How should the application be monitored?
  • What happens if the number of users increases?
These questions transform a normal software project into a cloud architecture problem.
And that is exactly what I want to learn.

🧠 From β€œDoes It Work?” to β€œHow Should It Work?”

This is probably the biggest change AWS is bringing to the way I think about software development.
Previously, I might ask:
  • β€œDoes my application work?”
Now I am beginning to ask:
  • β€œHow should my application work in a real environment?”
A production application needs to think about much more than functionality.
Some of the areas I'm beginning to consider are:
  • Security
  • Scalability
  • Reliability
  • Availability
  • Performance
  • Monitoring
  • Cost
  • Failure recovery
This is teaching me to think beyond individual lines of code. I'm beginning to think about the whole system.

πŸ§ͺ Starting With Small Projects

I don't think my first AWS project needs to be a huge application.
In fact, I believe small projects can provide a better learning experience.
Some of the projects I want to explore include:

πŸ“¦ Project 1 - Cloud File Storage

Build an application that uploads and retrieves files using Amazon S3.
What I can learn:
  • Object storage
  • Buckets
  • Permissions
  • File management
  • Cloud resource management

πŸ–₯️ Project 2 - Deploy a Web Application

Take a small application I've already built and explore how to deploy it on AWS.
What I can learn:
  • Compute
  • Deployment
  • Networking
  • Server management

⚑ Project 3 - Serverless Backend

Create a small backend function using AWS Lambda.
What I can learn:
  • Serverless computing
  • Event-driven architecture
  • Function-based applications

πŸ—„οΈ Project 4 - Cloud Database

Connect an application to a managed AWS database service.
What I can learn:
  • Managed databases
  • Connectivity
  • Security
  • Data management

🌐 Project 5 - Complete Cloud Application

Eventually combine multiple AWS services into one meaningful application.
What I can learn:
  • Cloud architecture
  • Service integration
  • Security
  • Monitoring
  • Scalability
The goal isn't to use as many AWS services as possible. The goal is to understand why each service is being used.

🌱 Why I Want to Learn by Building

There is a big difference between knowing what a technology is and knowing how to actually use it. I can read about Amazon EC2, watch a tutorial about Amazon S3, or memorize what AWS Lambda does, but that doesn't necessarily mean I understand how these services work in a real application. For me, practical experience comes from using the technology, experimenting with it, and solving problems with it. Learning gives me knowledge, building gives me experience, making mistakes gives me understanding, and improving gives me confidence. That's why I want projects to be at the center of my AWS learning journey. I believe every project can teach me something that a tutorial alone cannot.

πŸ—ΊοΈ My AWS Learning Roadmap

I'm still at the beginning of my AWS journey, so my focus is on building a strong foundation rather than jumping directly into advanced architectures. I first want to understand the fundamentals of cloud computing, including AWS Regions, Availability Zones, the Shared Responsibility Model, and basic pricing concepts. From there, I want to become comfortable with core AWS services such as Amazon EC2, Amazon S3, AWS IAM, Amazon RDS, Amazon DynamoDB, and AWS Lambda.
As I progress, I also want to strengthen my understanding of networking by exploring concepts such as Amazon VPCs, subnets, route tables, security groups, and communication between cloud resources. Security is another important area of my learning journey, particularly IAM, policies, roles, authentication, authorization, and secure resource access. I also want to understand monitoring and reliability, including application monitoring, logging, troubleshooting, availability, and failure handling. Ultimately, I want to bring these concepts together through real projects that solve practical problems. I know this roadmap will probably change as I learn more, and I'm completely okay with that because learning is an ongoing process.

🌍 Learning From Other Builders

Another part of my AWS journey that I value is learning from other developers and builders. Reading about how people approach real-world problems, design applications, and overcome technical challenges gives me ideas for my own projects and helps me see different ways of thinking. It also reminds me that experienced developers and cloud professionals didn't become experts overnight. Everyone started somewhere, with their first AWS service, first deployment, first configuration mistake, first failed experiment, and eventually their first successful project. Seeing those journeys motivates me to keep learning and reminds me that making mistakes is a normal part of becoming a better builder.

🎯 My Goal Isn't to Know Everything

AWS is enormous, and there will always be another service, another architecture, another technology, or another concept to learn. Because of that, I don't want my goal to be β€œI need to know everything about AWS.” Instead, I want to become confident enough to understand a problem, evaluate possible solutions, and choose the right cloud technologies to solve it. I want to eventually look at a software problem and think beyond the code by considering architecture, infrastructure, security, scalability, reliability, monitoring, and cost. For me, that is a much more meaningful goal than simply collecting knowledge about individual AWS services.

πŸš€ What Comes Next?

The next stage of my journey is about turning what I'm learning into actual projects. I want to take applications I already know how to build and gradually introduce cloud technologies into them instead of learning everything only in theory. My plan is simple: build something small, deploy it, break it, understand why it broke, secure it, monitor it, and improve it. Then I'll take what I learned and use it to build something a little more challenging. Over time, I hope these projects will help me understand how real cloud-based systems are designed and give me the practical experience I need to grow from a developer who writes code into a builder who can design and operate complete cloud-based solutions.

☁️ Final Thoughts

Starting AWS has changed the way I look at software development. I started with the question, β€œHow do I learn AWS?”, but now I'm asking, β€œWhat can I build with AWS?” That change in perspective has made cloud computing feel much less intimidating. I don't know every AWS service, I haven't mastered cloud architecture, and I don't expect to become an expert overnight. But I don't need to. I just need to keep learning and building-one service, one experiment, one project, one mistake, and one lesson at a time. Learn β†’ Build β†’ Break β†’ Understand β†’ Improve. I'm still at the beginning of my AWS journey, but now I have a clearer idea of where I want to go: from writing code to building reliable systems in the cloud. And this is only the beginning. β˜οΈπŸš€

ο»Ώ

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article