How to Talk About Your Cloud Projects in Interviews
What you build: a STAR answer for cloud interviews from a real lab: a Cloud Run load test (0 failed, p95 64 ms), a broken release caught on its tag URL, and a script that uses only measured numbers.

✍️ Translate this blog into Hindi, Tamil or Telugu
"Tell me about a project you worked on" is the most important question in a cloud interview, and the one most freshers answer worst: a list of services ("I used Cloud Run, Cloud Build and IAM...") with no story and no numbers. Interviewers want to hear what you built, what went wrong, what you did, and what you measured. In this post you learn a simple structure for that answer (STAR), the five things interviewers listen for, and you run a small lab that collects real numbers from a project on Google Cloud and turns them into an answer you can say with confidence, because every number in it is true.
Who it is for: students, freshers and career-changers preparing for cloud, DevOps or SRE interviews. Time: 30 minutes for the lab, plus practice. Cost: the lab stays inside Cloud Run's free tier (a few hundred requests for a few minutes).
The lab was run for real by the CareerByteCode Team on a fresh Google Cloud project, and every number in the story below comes from its real output.
🎓⭐ Recommended by CareerByteCode · Live trainingAWS Cloud Architecture and AIOps Bootcampโน10,620See the training →Part A: how to talk about a project

STAR is a simple order for your answer:
| Part | Say | Example |
|---|---|---|
| Situation | The context in one sentence | "I built a small web service on Cloud Run to practise production-style apps." |
| Task | What you had to achieve | "Prove it handles load and recovers from a bad release quickly." |
| Action | What you did, step by step, with tools as verbs | "I load-tested it with 500 requests, then released a broken version with no traffic and tested it on its own URL." |
| Result | Numbers: speed, errors, time saved, cost | "0 failed requests, 95th percentile 64 ms; the broken release never reached users." |
| (L)earned | One honest lesson | "Test new revisions on a tag URL before sending traffic." |
What interviewers listen for, in order:
- Ownership: "I did", not "we used".
- A problem: something that broke or could break. A project with no problems sounds like a tutorial.
- Trade-offs: why this tool and not another ("Cloud Run, because the app is stateless and traffic is low").
- Numbers: latency, errors, cost, time. One real number beats ten adjectives.
- What you would do next: shows you understand the limits ("next I would add an alert on the 5xx rate").
Real-life example: a cricket commentator. "He played well" says nothing; "he scored 64 off 50 balls, and survived a dropped catch at 12" tells the story.
The rule that makes it work: never invent numbers. Interviewers ask follow-up questions, and only real numbers survive them. That is why the lab below measures them.
Part B: the lab, collect real numbers
Before you start
- A Google Cloud account (the free trial works) and a project.
- Open Cloud Shell (the
>_icon at the top right of the console) and turn on Cloud Run:
export PROJECT_ID="your-project-id"
gcloud config set project $PROJECT_ID
gcloud services enable run.googleapis.com- Save this script as
story.pyin a folder~/lab321(mkdir -p ~/lab321 && cd ~/lab321, thennano story.py). It reads the numbers the lab saves inmetrics.jsonand fills in the STAR answer. It contains no numbers of its own.
# story.py: turn REAL numbers from your lab into an interview answer (STAR: Situation, Task, Action, Result).
# Reads metrics.json (written by the lab steps) and prints the story. Every number comes from the lab, none is invented.
import json
m = json.load(open("metrics.json"))
print(f"""SITUATION: I built a small web service on Google Cloud Run to practise running production-style apps.
TASK: Prove it handles load and recovers from a bad release quickly.
ACTION: I load-tested it with {m['requests']} requests ({m['concurrency']} at a time) using ab, then released
a broken version with no traffic, tested it on its own URL, and kept users on the good version.
RESULT: {m['failed']} failed requests, {m['rps']} requests per second, median {m['p50_ms']} ms and 95th percentile
{m['p95_ms']} ms; the broken release was caught before users saw it (test URL returned HTTP {m['bad_status']}),
and confirming all traffic on the good version took {m['switch_s']} s.
LEARNED: Test new revisions on a tag URL before sending traffic; latency at the 95th percentile matters more than the average.""")Step 1: a small project to talk about
Why: Google's sample web service on Cloud Run, with a named first revision (v1). ab (ApacheBench) is the load tester we use next.
# A small project to talk about: Google's sample web service on Cloud Run (good revision = "v1")
sudo apt-get update -qq && sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq apache2-utils > /dev/null 2>&1 && ab -V | head -1
gcloud run deploy story-app --image=us-docker.pkg.dev/cloudrun/container/hello --region=us-east1 --allow-unauthenticated --max-instances=3 --revision-suffix=v1 --quiet 2>&1 | grep -E "Service URL|serving"This is ApacheBench, Version 2.3 <$Revision$>
Service [story-app] revision [story-app-v1] has been deployed and is serving 100 percent of traffic.
Service URL: https://story-app-PROJECT_NUMBER.us-east1.run.appStep 2: collect real numbers with a load test
Why: 500 requests, 20 at a time. The numbers that matter in interviews: failed requests, requests per second, and percentiles: the 50th percentile (median) is a typical user, the 95th is your slowest 1 in 20 users. -l tells ab that pages may differ in length, which is not a failure.
# Collect real numbers: 500 requests, 20 at a time (-l: pages may differ in length, that is not a failure)
cd ~/lab321
URL=$(gcloud run services describe story-app --region=us-east1 --format="value(status.url)")
ab -q -l -n 500 -c 20 $URL/ > ab.txt 2>&1; grep -E "Complete requests|Failed requests|Requests per second| 50%| 95%| 99%" ab.txt
python3 -c "
import json, re; t = open('ab.txt').read(); g = lambda p: re.search(p, t).group(1)
json.dump({'requests': int(g(r'Complete requests:\s+(\d+)')), 'concurrency': 20, 'failed': int(g(r'Failed requests:\s+(\d+)')), 'rps': g(r'Requests per second:\s+([\d.]+)'), 'p50_ms': g(r' 50%\s+(\d+)'), 'p95_ms': g(r' 95%\s+(\d+)')}, open('metrics.json', 'w'))
print('saved metrics.json')"Complete requests: 500
Failed requests: 0
Requests per second: 385.98 [#/sec] (mean)
50% 52
95% 64
99% 70
saved metrics.json
Step 3: a broken release, caught before users see it
Why: a good story has a problem. Here we release a version that answers HTTP 500 (a server error), deploy it with no traffic under the tag candidate, test it on its own URL, and make sure users stay on v1.
# A broken release (it answers HTTP 500), deployed with NO traffic and tested on its own tag URL before any user sees it
cd ~/lab321
gcloud run deploy story-app --image=docker.io/hashicorp/http-echo:1.0 --args="-text=oops,-status-code=500,-listen=:8080" --port=8080 --region=us-east1 --no-traffic --tag=candidate --revision-suffix=v2 --quiet 2>&1 | grep -E "revision \[" | cut -c1-160 | head -1
URL=$(gcloud run services describe story-app --region=us-east1 --format="value(status.url)")
C=$(echo $URL | sed 's#https://#https://candidate---#'); B=$(curl -s -o /dev/null -w "%{http_code}" $C/); echo "candidate URL: HTTP $B"
S=$(date +%s); gcloud run services update-traffic story-app --region=us-east1 --to-revisions=story-app-v1=100 --quiet > /dev/null 2>&1; W=$(( $(date +%s) - S ))
echo "users: HTTP $(curl -s -o /dev/null -w '%{http_code}' $URL/), traffic confirmed on v1 in $W s"
python3 -c "import json; m = json.load(open('metrics.json')); m.update(bad_status='$B', switch_s=$W); json.dump(m, open('metrics.json', 'w')); print(json.dumps(m))"Service [story-app] revision [story-app-v2] has been deployed and is serving 0 percent of traffic.
candidate URL: HTTP 500
users: HTTP 200, traffic confirmed on v1 in 1 s
{"requests": 500, "concurrency": 20, "failed": 0, "rps": "385.98", "p50_ms": "52", "p95_ms": "64", "bad_status": "500", "switch_s": 1}The candidate's own URL returned HTTP 500, so it was caught before any user saw it; users kept getting HTTP 200. All the numbers are now saved in metrics.json.
Step 4: turn the numbers into your answer
# Turn the real numbers into an interview answer (STAR)
cd ~/lab321
python3 story.pySITUATION: I built a small web service on Google Cloud Run to practise running production-style apps.
TASK: Prove it handles load and recovers from a bad release quickly.
ACTION: I load-tested it with 500 requests (20 at a time) using ab, then released
a broken version with no traffic, tested it on its own URL, and kept users on the good version.
RESULT: 0 failed requests, 385.98 requests per second, median 52 ms and 95th percentile
64 ms; the broken release was caught before users saw it (test URL returned HTTP 500),
and confirming all traffic on the good version took 1 s.
LEARNED: Test new revisions on a tag URL before sending traffic; latency at the 95th percentile matters more than the average.
Read it out loud. Every number came from this lab, so you can answer any follow-up: "how did you measure the 95th percentile?", "what did the broken version do?", "how would you catch it automatically?".
🎓⭐ Recommended by CareerByteCode · Live trainingAzure Cloud Architecture and AIOps Bootcampโน10,620See the training →Part C: practise the follow-ups
Interviewers dig into one part of your story. Prepare short answers for these:
| They ask | A good answer uses |
|---|---|
| "Why Cloud Run and not Kubernetes?" | Stateless app, low traffic, no cluster to manage; Kubernetes when you need more control or many services |
| "What would break first under more load?" | The 95th percentile rising; then instance limits (--max-instances), then the database if there is one |
| "How would you catch the bad release automatically?" | A smoke test in the pipeline that calls the tag URL and stops if it is not 200 |
| "What did it cost?" | Requests and instance time stayed in the free tier; name the cost driver (instance time) |
| "What would you do next?" | Alert on the 5xx rate, a canary step (10 percent traffic) before 100 percent |
POC: prove it works
- A Cloud Run service handled 500 requests with 0 failures, about 386 requests per second, a 52 ms median and a 64 ms 95th percentile.
- A broken release (HTTP 500) was deployed with no traffic and caught on its tag URL; users kept HTTP 200.
story.pyturned only those measured numbers into a STAR answer.
Quiz task: check what you learned
- What do the letters in STAR stand for? (Answer: situation, task, action, result.)
- Why is the 95th percentile more useful than the average? (Answer: it shows the experience of your slowest users, which an average hides.)
- Rewrite "We used Cloud Build and Cloud Run" with ownership. (Answer: "I built a pipeline with Cloud Build that tested and deployed the app to Cloud Run.")
- Your project had no problems. What do you do? (Answer: create one on purpose (a bad release, a load test) and show how you handled it.)
- An interviewer asks a number you do not know. What do you say? (Answer: say you did not measure it, and how you would.)
Clean up (delete everything)
# Clean up: delete the service
cd ~/lab321
gcloud run services delete story-app --region=us-east1 --quiet 2>&1 | tail -1
rm -f ab.txt metrics.json
echo "services left: $(gcloud run services list --format='value(name)' | grep -c story-app)"Deleted service [story-app].
services left: 0
FAQ
I only did tutorials. Do they count as projects? Yes, if you made them yours: change something, break something, measure something, and write it down. That turns a tutorial into a project.
How long should the answer be? About 1.5 to 2 minutes. Then stop and let them ask follow-ups; they will.
Should I talk about team projects? Yes, but say clearly which part was yours.
What if I do not know an answer to a follow-up? Say so, then explain how you would find out. Interviewers value honest reasoning over guessing.
How many stories should I prepare? Three: one about building, one about a failure you fixed, one about a trade-off you made.
Where do I find more numbers? Cloud Run metrics and logs (latency, request count, error rate), build times from Cloud Build, and costs from the billing reports.
Troubleshooting
| You see | Why | Fix |
|---|---|---|
ab reports many Failed requests | Pages differ in length | Add -l to ab |
ab: command not found | ApacheBench not installed | sudo apt install apache2-utils |
| The candidate URL does not work | No tag was given | Deploy with --tag=candidate (and --no-traffic) |
story.py fails with KeyError | metrics.json is missing a field | Run Steps 2 and 3 first, in order |
| Numbers change on every run | Load tests vary | Run 3 times and quote a typical value |
What next
- Build a bigger project to talk about: CI/CD for Beginners: Build and Deploy on Every Git Push.
- Add logs to your story: Cloud Logging Hands-On: Find Any Error in Seconds.
- Add a cost angle: FinOps for Beginners: Read and Cut Your Cloud Bill.
- More hands-on posts: ByteBlog. Practice in ByteLabs and see the courses.
Prepared by the CareerByteCode Team from our tested lab, with AI help for the write-up.
⭐ Keep learning with CareerByteCode
Hand-picked to go deeper on this topicGet CareerByteCode Team's next blog by email
One email a week when they publish. Add the weekly Best of ByteBlog too. No spam, unsubscribe with one click.
We email you once to confirm. By subscribing you agree to the privacy policy.
Related blogs
CareerByteCode TeamCloud Engineer Fresher Roadmap: 12 Labs in 12 Weeks
What you build: a 12-week cloud engineer plan for freshers with one tested lab every week, plus a real Week 0 readiness check that proves billing, a budget, a free VM and a bucket work.
#beginners
CareerByteCode TeamGoogle Cloud for Absolute Beginners: Projects, Billing and Console
What you build: a new Google Cloud project, linked to billing, with a budget alert and a free e2-micro virtual machine, all deleted at the end. Every step tested.
#beginners
CareerByteCode TeamKubernetes Roadmap: From Pods to Platform Engineering
What you build: an 8-level Kubernetes roadmap from pods to platform engineering, with a real script that checks every level on GKE (pod, service, config, probes, HPA, RBAC, Helm, as code).
#beginners
CareerByteCode TeamDevOps Engineer Roadmap 2027 with Hands-On Labs
What you build: a 2027 DevOps roadmap in 7 stages where every stage links to a tested lab, plus a real 15-minute lab that runs the whole loop: code, build, deploy, observe and roll back.
💬 Comments (0)
Top · NewestSign in to comment