AWS Builder Center

What I Learned While Building on AWS: 10 Lessons That Changed How I Think About the Cloud

Building on AWS is about more than choosing services—it’s about learning to make thoughtful decisions around simplicity, security, reliability, observability, and cost. This article shares practical lessons from the journey of building, making mistakes, and continuously improving in the cloud.

What I Learned While Building on AWS: 10 Lessons That Changed How I Think About the Cloud

When I first started learning AWS, I thought the biggest challenge would be remembering the names of all the services.
I was wrong.
The real challenge was learning how to think in the cloud.
At first, I approached AWS like a catalog. I would see a problem and immediately start asking, “Which AWS service should I use?” Over time, through experimenting, building small projects, making mistakes, and rebuilding things, I learned that choosing a service is often the easier part.
The more important questions are:
  • What problem am I actually trying to solve?
  • What happens when something fails?
  • How will I know when it fails?
  • Is my solution secure?
  • Am I paying for resources I don't need?
  • Can I change or improve this later?
These lessons apply whether you're building your first cloud project or designing a production workload. Here are ten lessons that changed the way I think about building on AWS.

1. Start with the problem, not the AWS service

It's easy to start with a technology.
“I want to use AWS Lambda.”
“I want to build something with Amazon EC2.”
“I want to try Amazon DynamoDB.”
There's nothing wrong with wanting to learn a service. But when building a real solution, starting with the service can lead to unnecessary complexity.
A better approach is to describe the problem first.
For example:
“I need to receive files from users, process them, and notify the user when processing is complete.”
Now the architecture can evolve from the requirements. You can think about storage, processing, events, security, notifications, and failure handling before becoming attached to a specific service.

My takeaway

Services are tools. Requirements should drive the architecture.
AWS gives builders many choices, but having more choices also means we need to be intentional about why we're making them.



2. Simple architectures are often better architectures

One of my early instincts was to make architectures more sophisticated than necessary.
More services seemed more “cloud native.” More components seemed more scalable. More diagrams seemed more impressive.
But every additional component introduces something else to configure, secure, monitor, understand, and maintain.
A simple architecture might begin with:
  1. A user sends a request.
  1. An application processes it.
  1. Data is stored.
  1. The result is returned.
That may be enough.
The architecture can become more sophisticated when real requirements justify the change: increased traffic, asynchronous processing, resilience requirements, security boundaries, or other needs.

My takeaway

Don't optimize for architectural complexity. Optimize for the problem you need to solve.
Simple doesn't mean careless. It means understanding what is necessary—and what isn't.



3. IAM is not something to learn “later”

AWS Identity and Access Management (IAM) was one of the areas I initially wanted to postpone.
Permissions can feel like friction when you're trying to build quickly. You just want your application to work.
But permissions are part of making the application work correctly.
A common learning experience is granting broad permissions because something isn't working. The application starts working, so the problem appears solved—but the underlying lesson may be missed.
Over time, I learned to ask:
  • Which identity is making this request?
  • Which AWS resources does it actually need?
  • Which actions are required?
  • Can I reduce the permissions further?
This way of thinking changes IAM from being an obstacle into a design tool.

My takeaway

Security isn't a final step before deployment. It is part of the architecture from the beginning.
The AWS Well-Architected Framework also treats security as a core architectural consideration alongside operational excellence, reliability, performance efficiency, cost optimization, and sustainability.



4. If you can't observe it, you can't confidently operate it

An application can appear to work perfectly during testing and still fail in unexpected ways later.
A request might time out. A dependency might become unavailable. A permission might change. A function might fail only for a particular input.
That's when observability becomes important.
I've learned to think about logging, metrics, alarms, and traces as part of the application—not as optional additions after everything else is finished.
When something goes wrong, the goal shouldn't be to guess.
You should be able to ask:
  • What happened?
  • When did it happen?
  • Which component failed?
  • How many users were affected?
  • Is the issue still happening?

My takeaway

“It works on my machine” is not an operational strategy.
The sooner you add meaningful observability, the easier it becomes to understand how your system behaves.



5. Serverless doesn't mean “nothing can go wrong”

Serverless services can remove a significant amount of infrastructure management. That's a huge advantage.
But serverless does not remove the need for engineering decisions.
You still need to think about:
  • Error handling
  • Permissions
  • Retries
  • Timeouts
  • Data consistency
  • Event processing
  • Cost
  • Monitoring
The lesson for me was simple: managed infrastructure reduces operational responsibility; it doesn't eliminate application responsibility.
Instead of managing servers, builders can spend more time thinking about the behavior of their workloads. That's powerful—but only if we use that time well.



6. Design for failure before failure teaches you the lesson

At some point, every builder encounters a failure they didn't expect.
A service call fails.
A message is delivered more than once.
A dependency becomes slow.
A deployment introduces an unexpected problem.
The question isn't whether systems can fail. The question is whether the architecture can respond when they do.
This changed how I think about “happy path” development. A successful request is only one possible outcome.
Now I try to consider questions such as:
  • What happens if this operation fails?
  • Should it be retried?
  • Could a retry create duplicate work?
  • Where should failed requests go?
  • How will we recover?
The AWS Well-Architected Framework similarly emphasizes foundations, workload architecture, change management, and failure management as important areas for building reliable workloads.

My takeaway

Resilience isn't created when everything works. It's revealed when something doesn't.



7. Cost awareness should begin on day one

One of the biggest differences between experimenting locally and building in the cloud is that resources can have ongoing costs.
A resource created for a quick experiment can continue running long after the experiment ends.
This taught me to develop a few habits:
  • Understand the pricing model before creating resources.
  • Use tags consistently.
  • Delete resources that are no longer needed.
  • Review what is actually being used.
  • Treat cost as an engineering consideration, not just a finance concern.
Cost optimization isn't always about choosing the cheapest option. Sometimes paying more for a managed service can reduce operational effort. Sometimes reducing resources can also reduce performance or reliability.
Architecture involves trade-offs.

My takeaway

The cheapest architecture isn't always the best architecture—but every resource should have a reason to exist.
AWS identifies cost optimization as one of the six pillars of the Well-Architected Framework and describes it as a continuous process of improving how systems deliver business value.



8. Automate the things you expect to repeat

Manual configuration is useful for learning.
It helps you understand what happens behind the scenes. But repeating the same manual steps creates opportunities for mistakes and makes environments harder to reproduce.
That is why Infrastructure as Code (IaC) changed how I think about cloud infrastructure.
Instead of relying entirely on memory and console clicks, infrastructure can be described, versioned, reviewed, and reproduced.
This doesn't mean every experiment needs a perfect infrastructure pipeline. The important lesson is recognizing when manual work is becoming repetitive.

My takeaway

If a process is important enough to repeat, it may be important enough to automate.
Automation makes it easier to rebuild environments and improves confidence that systems are being created consistently.



9. Documentation is part of the build

When building something new, documentation can feel less exciting than writing code or configuring a service.
But a few weeks later, you may ask yourself:
“Why did I design it this way?”
Documentation helps answer that question.
I don't think documentation always needs to be long. Sometimes the most valuable information is simply:
  • What problem does this architecture solve?
  • What are the major components?
  • What assumptions does it make?
  • Why were important decisions made?
  • What should the next builder know?
Even a simple architecture diagram and a short README can dramatically reduce the time needed to understand a project later.

My takeaway

Good documentation helps future collaborators—and your future self.



10. The fastest way to learn AWS is to build, break, and improve

Courses and documentation are valuable. But some lessons only become clear when you build something yourself.
Build a small application.
Deploy it.
Make a mistake.
Investigate the mistake.
Fix it.
Improve the design.
Then repeat.
This cycle helped me move from memorizing AWS services to understanding how they can work together.
The AWS Well-Architected Framework is also useful as a way to evaluate and improve an architecture over time rather than treating design as a one-time activity.

My takeaway

You don't need to know everything before you start building. You learn by building responsibly and reflecting on what happens.



Final thoughts

My biggest lesson from learning AWS is that cloud building is not really about collecting services and certifications.
It's about learning how to make better technical decisions.
A strong cloud solution considers more than whether the application works today. It considers how the system will be secured, operated, monitored, changed, scaled, recovered, and improved.
The AWS ecosystem can initially feel enormous, and that's okay. You don't need to understand every service before building something useful.
Start with a problem.
Choose the simplest reasonable solution.
Build it.
Observe it.
Question your assumptions.
Learn from what breaks.
Then improve it.
That process has taught me more than any attempt to memorize a list of AWS services—and I believe that's what makes cloud building such a rewarding journey.

What lessons have you learned?

Every builder has a different first project, first mistake, and first “aha!” moment.
If you're learning AWS, I'd encourage you to share your lessons with the community too. Sometimes the most valuable article isn't one that presents a perfect architecture. It's one that honestly explains what didn't work, what changed, and what you would do differently next time.
Because in the end, we don't become better builders by avoiding mistakes.
We become better builders by learning from them.
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