You Built It. But Did You Secure It?
There’s a particular feeling when you finally deploy something you’ve been working on for hours.
The code works.
The deployment succeeds.
The application is live.
You think:
“Finally. It works.”
And then comes the question we sometimes forget to ask:
“Who can access it?”
That question changes everything.
Because a working application isn't necessarily a secure application.
Security isn't a final step
It's easy to think of security as something you add after the application is built.
Build → Deploy → Secure
But in cloud environments, security is closely tied to architecture. Decisions about permissions, networking, data and access should be considered while you're building, not after something goes wrong.
Take IAM.
If an application only needs to read objects from an S3 bucket, why give it permission to delete them? Why give it access to resources it never needs?
That's the principle of least privilege:
Give something only the access it actually needs.
Simple idea. Very easy to forget.
What about your secrets?
We've all seen API keys, passwords or credentials sitting somewhere they shouldn't.
Maybe it's in a configuration file.
Maybe it's in an environment variable that gets handled incorrectly.
Or, worst case, it ends up in a GitHub repository.
AWS provides services such as Secrets Manager to help manage sensitive information securely, but the bigger lesson is developing the habit of asking:
“Does this secret really need to be here, and who can access it?”
Is everything that can be public supposed to be public?
Cloud makes it incredibly easy to connect resources.
But connectivity isn't the same as necessity.
Your application might need a public-facing web layer. That doesn't mean your database needs to be publicly reachable too.
Before exposing a resource, ask:
“Does this actually need to be public?”
If the answer isn't clear, it's worth taking another look.
And what happens when something goes wrong?
Security isn't only about preventing unauthorized access.
It's also about knowing when something unusual happens.
If someone accesses a resource they shouldn't, can you tell?
Can you determine what happened and when?
Services such as AWS CloudTrail provide visibility into API activity, which can be critical when investigating unexpected behavior.
A useful question to ask is:
“If something suspicious happened in my AWS account tonight, would I know tomorrow?”
If the answer is no, that's something worth improving.
Build it. Then question it.
When you're working on a project, don't stop at:
“Does it work?”
Also ask:
- What permissions do they have?
- Are any resources unnecessarily public?
- Is sensitive data protected?
- Would I know if something went wrong?
You don't need a massive enterprise project to practice this.
Take your next small AWS project and try looking at it from the perspective of someone who shouldn't have access.
Find the weak points.
Fix them.
Then do it again.
Because security isn't something you add once your application is finished.
It's a mindset you build into the application from the beginning.
So the next time you deploy something and think:
“It works.”
Ask yourself one more question:
“But did I secure it?”
Loading article