AWS Security Fundamentals: What I'm Learning as a Beginner
A BCA student's ground-up walkthrough of AWS security basics — the Shared Responsibility Model, IAM, encryption, and network security — learned through Skill Builder and explained the way I wish someone had explained it to me.
AWS Security Fundamentals: What I'm Learning as a Beginner (and Why It Actually Makes Sense)
I'm a BCA student building toward a cybersecurity career — specifically GRC and SOC analyst roles — and I've been working through AWS Skill Builder to understand cloud security from the ground up. Here's what's clicked for me so far, explained the way I wish someone had explained it to me on day one.
The Question That Everything Starts With
Before you can secure anything in AWS, you have to answer one question: who is responsible for securing what?
That's it. That's the whole starting point. AWS didn't invent a new security philosophy — they just had to solve a real problem: if AWS runs the physical data centers, but you run your application on top of them, who's on the hook when something goes wrong?
The Shared Responsibility Model
AWS splits it cleanly:
- AWS secures the cloud — the physical data centers, the hardware, the network infrastructure, the hypervisor. You never touch this layer, and you don't need to.
- You secure what's in the cloud — your data, your access permissions, your configurations, your operating system patches (if you're running EC2), and how you set up your applications.
Here's the part that made it click for me: this isn't AWS being cagey about their infrastructure — it's a division of labor that scales. AWS can't know how sensitive your data is or who should have access to it. You can't (and shouldn't have to) verify the physical security of a data center in a different country. Each side controls what it can actually see and reason about.
Why Identity Comes Before Everything Else (IAM)
Once you accept that you're responsible for what's in your account, the next problem is obvious: how do you control who can do what?
This is where AWS Identity and Access Management (IAM) comes in. The core idea is simple but easy to get wrong in practice: never give more access than a task actually needs. This is called the principle of least privilege.
A few things that reframed how I think about IAM:
- Users, groups, and roles aren't just organizational conveniences — they're how you avoid the single biggest cloud security mistake: sharing one all-powerful login across a whole team.
- Roles vs. users matters more than it sounds: a role is temporary, assumable, and revocable access — ideal for applications and services that need to act on your behalf without a permanent password floating around.
- Policies are just JSON documents that answer one question — "is this specific action, on this specific resource, allowed?" Once I stopped trying to memorize IAM and started reading policies as literal yes/no questions, it stopped being intimidating.
Encryption: Protecting Data at Rest and in Transit
The next layer down is: even if someone gets unauthorized access, can they actually read what they find?
- Data at rest (sitting in storage, like an S3 bucket or an EBS volume) gets encrypted so a stolen disk or leaked snapshot is useless without the key.
- Data in transit (moving between services, or from a user to your app) gets encrypted so it can't be intercepted mid-flight.
AWS Key Management Service (KMS) is the piece that ties this together — it manages the encryption keys so you're not reinventing key rotation and access control from scratch.
The Network Layer: Security Groups and NACLs
This is where I had to slow down, because the two concepts look similar but behave differently:
- Security Groups act like a bouncer at the door of an individual EC2 instance — stateful, meaning if you allow traffic in, the response traffic out is automatically allowed.
- Network ACLs (NACLs) sit at the subnet level — stateless, meaning inbound and outbound rules are evaluated independently, so you have to explicitly allow both directions.
The reasoning behind having both: Security Groups give you fine-grained, per-resource control; NACLs give you a broader safety net at the network boundary. Defense in depth isn't a slogan here — it's literally two independent layers that both have to be misconfigured for a mistake to become a breach.
Visibility: You Can't Secure What You Can't See
The last fundamental that tied everything together for me is AWS CloudTrail. Every action taken in an AWS account — who logged in, what they changed, what API call they made — gets logged.
For someone aiming at GRC and SOC work specifically, this is the piece that matters most day-to-day: security isn't just about locking things down, it's about being able to answer "what happened, and who did it?" after the fact. CloudTrail is the audit trail that makes accountability possible.
Why I'm Learning This Through Skill Builder
What's worked for me is that Skill Builder doesn't just hand you definitions — the labs force you to actually configure an IAM policy or set up a security group and watch it break (or work) in real time. For someone coming from a BCA background without hands-on infrastructure experience, that gap between "I read the definition" and "I configured it myself and saw why it matters" has been the whole difference.
Next up, I'm working toward the AWS Certified Cloud Practitioner as a foundation before going deeper into security-specific paths.
If you're a student on a similar path, verify your student status on Builder Center — Skill Builder Premium access is part of the Student Rewards program.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article