Cloud practice with proof up front
I practiced cloud engineering through an AWS Cloud Support Engineer internship and small public deployments. The internship focused on guided rotations and troubleshooting labs rather than production customer work, and my personal projects focus on small deployments where limitations and cost tradeoffs are documented.- AWS internship: guided support rotations in training environments, not direct ownership of live customer tickets.
- Serverless capstone: Lambda, DynamoDB, S3, Amplify, and a metadata extraction workflow.
- Cost modeling: documented estimates for upload and retrieval costs using explicit assumptions.
- Public proof: Render and GitHub Pages deployments plus blog posts about AWS budgets and free-tier mistakes.
Clear scope, upfront
What I have
- Guided AWS internship reps with troubleshooting notes and written assumptions.
- Small public deployments on GitHub Pages and Render.
- Write-ups that document failures, costs, and limitations instead of hiding them.
What I am still working toward
- Ownership of production AWS environments or multi-account architecture design.
- On-call rotations or customer ticket ownership.
- Deeper IAM and security review experience outside labs.
What I’m doing next
- IAM policy drills and security review practice.
- Terraform plan/apply reps in a sandbox account.
- Small monitoring project with alerts + cost guardrails.
What my 'cloud' reps actually look like
Internship practice (internal + lab-style)
I did real cloud practice in the internship, but it happened in guided environments. That matters because the work was useful and technical, while still being different from owning live customer infrastructure.
- Cloud Support Engineer Intern (Capstone Project), AWS, Seattle, WA, May 2025 - Aug 2025.
- Built a serverless metadata extraction workflow using Lambda, DynamoDB, S3, and Amplify.
- Implemented a documented cost model for upload and retrieval estimates.
- Worked in guided rotations and lab-style environments rather than production customer accounts.
Personal deployments (public, small-scale)
Outside the internship, my cloud reps come from deploying and documenting smaller projects where the limitations are visible and easy to audit.
- Car-Match backend deployed to Render with README troubleshooting notes.
- Interactive Pokédex and AnimalSounds deployed to GitHub Pages.
- Free-tier cold starts can take several minutes; this limitation is documented in project READMEs.
- Blog posts documenting how I configure budgets, monitor bills, and keep honesty logs of what’s broken.
Proof (student-level, transparent)
AWS internship labs
The strongest cloud proof I have right now comes from the internship capstone and the documentation around it.
- Built CloudWatch dashboards + SNS alerts for sample environments (documented in internship recap post).
- Automated repetitive lab support workflows using shell scripts and AWS CLI.
- Capstone: metadata extraction workflow with a documented cost model for review.
- Logged every limitation so the page does not overstate the work.
Portfolio prototypes
- Car-Match repo shows env vars, README troubleshooting notes, and Render deployment notes.
- Interactive Pokédex and AnimalSounds document GitHub Pages deployment steps.
Stack in rotation (with AI help)
Each repository documents the maturity of the tools used. Experimental work is explicitly labeled in the project documentation.
Mentorship wishlist
- Designing real multi-account AWS environments (beyond labs).
- Deep dive into IAM policy design and security reviews.
- Automated testing/validation for Terraform + deployment pipelines.
- Incident response expectations in real production settings.
If you are hiring for junior cloud roles and provide coaching in these areas, I am open to discussing opportunities.
Core Responsibilities
A Cloud Engineer is responsible for designing, deploying, and maintaining cloud infrastructure and services. Key responsibilities include:
- Cloud architecture: Designing scalable, cost-effective infrastructure on AWS using services like Lambda, S3, DynamoDB, and API Gateway (Source).
- Infrastructure as Code (IaC): Provisioning resources with Terraform or AWS CloudFormation instead of manual console clicks (Source).
- Cost management: Monitoring cloud spend, setting budgets and billing alerts with AWS Budgets, and optimizing free-tier usage.
- Security and IAM: Designing least-privilege IAM policies, using IAM Access Analyzer to find unintended access, and reviewing security groups.
- Monitoring and alerting: Setting up CloudWatch dashboards, log groups, and SNS alerts for operational visibility.
- Serverless development: Building event-driven workflows with AWS Lambda triggered by S3 events, API Gateway, or EventBridge.
- Deployment and CI/CD: Using GitHub Actions for build validation and deploying static sites to GitHub Pages or services to Render.
Key Skills
- Cloud platform: AWS — Lambda (Source), S3 (Source), DynamoDB (Source), IAM (Source)
- Infrastructure as Code: Terraform (Source), AWS CloudFormation (Source)
- Monitoring: CloudWatch (Source), SNS (Source)
- Serverless: AWS Lambda, API Gateway (Source), Amplify (Source)
- CI/CD: GitHub Actions (Source)
- Containerization: Docker Compose (Source)
- CLI tools: AWS CLI (Source)
Tools and Technologies
| Tool | Category | My Maturity Level | Official Docs |
|---|---|---|---|
| AWS Lambda | Serverless compute | Capstone + lab | Lambda |
| Amazon S3 | Object storage | Capstone + lab | S3 |
| Amazon DynamoDB | NoSQL database | Capstone + lab | DynamoDB |
| AWS IAM | Access management | Lab only | IAM |
| CloudWatch | Monitoring | Lab + personal | CloudWatch |
| AWS Amplify | Full-stack platform | Capstone | Amplify |
| Terraform | Infrastructure as Code | Tutorial stage | Terraform |
| GitHub Actions | CI/CD | Personal CI basics | GitHub Actions |
| Docker Compose | Local containers | Local dev only | Docker Compose |
| Render | App deployment | Personal deploys | Render |
Role Comparison: Cloud Engineer vs. Adjacent Roles
| Dimension | Cloud Engineer | DevOps Engineer | Backend Engineer | Site Reliability Engineer |
|---|---|---|---|---|
| Primary focus | Cloud infra design, IaC, cost | CI/CD pipelines, deployments | Server logic, APIs, databases | Uptime, reliability, incidents |
| Core tools | Terraform, AWS CLI, IAM | GitHub Actions, Docker, Bash | Express, FastAPI, MongoDB | Prometheus, Grafana, PagerDuty |
| Cloud involvement | High — designs and provisions | Medium — deploys to cloud | Low — deploys apps to cloud | High — operates cloud infra |
| IaC experience | High — core skill | Medium — uses IaC for pipelines | Low | Medium — uses IaC for fixes |
| On-call | Sometimes | Sometimes | Rarely | Always — primary role |
| Cost optimization | High — core responsibility | Low | Low | Low |
| Typical deliverable | Provisioned cloud resources | Working deployment pipeline | Deployed API service | Improved SLOs and runbooks |
| My current level | AWS internship, small deploys | Personal CI scripts | Small deployed APIs | Not pursuing |
Expanded Process Notes
How I approach a cloud deployment
- Map the architecture — Draw out which AWS services are needed (e.g., S3 for storage, Lambda for compute, DynamoDB for state) and how data flows between them. The AWS Well-Architected Framework provides the design principles I reference.
- Estimate costs upfront — Before building, I document expected costs per request using AWS pricing pages (Lambda pricing, S3 pricing). This was a core part of my internship capstone.
- Set up IAM with least privilege — Each service gets its own role with only the permissions it needs. IAM Access Analyzer helps identify over-permissive policies.
- Build serverless workflows — For event-driven tasks, I use Lambda functions triggered by S3 events (Source). My capstone project used this pattern for metadata extraction.
- Add monitoring from day one — CloudWatch dashboards and SNS alerts are configured before the workflow goes live so failures are visible immediately (Source).
- Document everything — Every deployment includes README notes about limitations, free-tier caveats, and what would need to change for production scale.
Common pitfalls I have encountered
- Free-tier cold starts: Render's free tier and AWS Lambda cold starts can introduce latency. This is documented in every project README.
- Accidental charges: Without billing alerts, it is easy to incur unexpected costs. I always set up AWS Budgets before deploying anything.
- Over-permissive IAM: Default policies that use
*actions or resources are a security risk. The principle of least privilege is documented in the IAM best practices guide.
References
- AWS Documentation — Overview
- AWS Lambda Developer Guide
- Amazon S3 User Guide
- Amazon DynamoDB Developer Guide
- AWS IAM User Guide
- IAM Access Analyzer
- Amazon CloudWatch User Guide
- Amazon SNS Developer Guide
- AWS Amplify Documentation
- Terraform Documentation
- GitHub Actions Documentation
- Docker Compose Documentation
- Render Documentation
- AWS Well-Architected Framework
- AWS Budgets
- AWS Lambda Pricing
- AWS CLI User Guide
