Skip to content

Cloud Engineer

Cloud Engineer

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.
Honesty upgrade

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.
Current practice

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.
Work samples

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.

Proof links: Internship recap post

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.

Proof links: Car-Match repo, Interactive Pokédex repo, Interactive Pokédex live, AnimalSounds repo, AnimalSounds live

Tools I'm exploring

Stack in rotation (with AI help)

CloudWatch dashboards - lab + personalIAM basics + Access Analyzer - lab onlyS3 / Lambda - capstone project + labGitHub Actions - personal CI basicsDocker Compose - local dev onlyTerraform - tutorial stage

Each repository documents the maturity of the tools used. Experimental work is explicitly labeled in the project documentation.

Where I need help

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

Tools and Technologies

ToolCategoryMy Maturity LevelOfficial Docs
AWS LambdaServerless computeCapstone + labLambda
Amazon S3Object storageCapstone + labS3
Amazon DynamoDBNoSQL databaseCapstone + labDynamoDB
AWS IAMAccess managementLab onlyIAM
CloudWatchMonitoringLab + personalCloudWatch
AWS AmplifyFull-stack platformCapstoneAmplify
TerraformInfrastructure as CodeTutorial stageTerraform
GitHub ActionsCI/CDPersonal CI basicsGitHub Actions
Docker ComposeLocal containersLocal dev onlyDocker Compose
RenderApp deploymentPersonal deploysRender

Role Comparison: Cloud Engineer vs. Adjacent Roles

DimensionCloud EngineerDevOps EngineerBackend EngineerSite Reliability Engineer
Primary focusCloud infra design, IaC, costCI/CD pipelines, deploymentsServer logic, APIs, databasesUptime, reliability, incidents
Core toolsTerraform, AWS CLI, IAMGitHub Actions, Docker, BashExpress, FastAPI, MongoDBPrometheus, Grafana, PagerDuty
Cloud involvementHigh — designs and provisionsMedium — deploys to cloudLow — deploys apps to cloudHigh — operates cloud infra
IaC experienceHigh — core skillMedium — uses IaC for pipelinesLowMedium — uses IaC for fixes
On-callSometimesSometimesRarelyAlways — primary role
Cost optimizationHigh — core responsibilityLowLowLow
Typical deliverableProvisioned cloud resourcesWorking deployment pipelineDeployed API serviceImproved SLOs and runbooks
My current levelAWS internship, small deploysPersonal CI scriptsSmall deployed APIsNot pursuing

Expanded Process Notes

How I approach a cloud deployment

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Add monitoring from day one — CloudWatch dashboards and SNS alerts are configured before the workflow goes live so failures are visible immediately (Source).
  6. 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