Fastly Interview Preparation Guide: 6-Week Plan (2027)
A six-week Fastly interview prep plan: HTTP caching, VCL, purging, Compute, logging, Terraform and security, with labs and 28 practice questions.
To prepare for a Fastly interview, spend about six weeks moving from HTTP caching basics to VCL, then Fastly Compute, observability, automation with Terraform and CI/CD, and finally security and design scenarios. Each week below has reading, a hands-on lab and practice questions, so you can prove skills instead of reciting definitions.
This is the study plan in our Fastly series. For beginner definitions, read Fastly engineer interview questions for freshers. For a quick question-and-answer bank on purging, shielding and WAF, use Fastly FAQs asked in DevOps interviews. Both sit under the 200+ DevOps interview questions hub.
Key takeaways
- Fastly interviews mix CDN knowledge with general DevOps skills: HTTP, TLS, DNS, logging, infrastructure as code and incident handling.
- Public candidate reports describe recruiter and hiring manager screens, technical or coding rounds and a final loop. The exact format depends on the role, so ask your recruiter.
- Hands-on proof matters. A small Compute app, a Terraform-managed service and a logging pipeline give you real stories to tell.
- Week 1 is HTTP caching, because most edge questions reduce to headers and TTLs.
- The plan ends with 28 practice questions that differ from the freshers and FAQ pages, plus a mock-interview checklist.
Who this plan is for
| Your background | Time needed | Where to focus |
|---|---|---|
| Fresher or support engineer | 6 weeks, about 1 hour a day | Weeks 1 to 3; skim weeks 5 and 6 |
| DevOps engineer, 2 to 5 years, new to Fastly | 4 weeks | Weeks 2 to 5; you likely know HTTP and Terraform |
| Senior or SRE with CDN experience | 2 weeks | Weeks 4 and 6; practise design answers out loud |
What Fastly interviews usually cover
Fastly does not publish a single interview syllabus, and the role decides the mix. Job descriptions on the Fastly careers page are the best guide for a specific opening. Across customer engineering, support, SRE and platform roles, the recurring topics are:
- HTTP semantics, caching rules and status codes
- TLS, DNS and TCP basics, plus how requests reach a POP
- VCL for Delivery services and WebAssembly-based Compute services
- Logging, metrics and troubleshooting from headers and logs
- Automation: API, CLI, Terraform and CI/CD
- Security at the edge: WAF, rate limiting, DDoS and origin protection
- For software roles, coding rounds; candidate reports mention Rust and systems topics
The six-week plan
| Week | Topic | Lab | Done when you can |
|---|---|---|---|
| 1 | HTTP caching and CDN basics | Put a free Fastly service in front of a test origin | Explain hit, miss, pass and every Cache-Control directive you use |
| 2 | VCL and the request lifecycle | Write snippets for redirects, header changes and backend routing | Trace a request through each subroutine on a whiteboard |
| 3 | Purging, surrogate keys, shielding | Tag responses with surrogate keys and purge by key | Choose between URL, key, soft and full purges for a given change |
| 4 | Fastly Compute | Build and publish a Compute app with the CLI | Say when Compute is the better fit and how you test it locally |
| 5 | Observability and automation | Stream logs to a store you control; manage the service with Terraform from CI | Find a slow backend from logs and roll back a change from Git |
| 6 | Security and design | Add rate limiting rules and lock the origin to Fastly traffic | Talk through a multi-CDN or origin-failover design for 10 minutes |
Week 1: HTTP caching and CDN basics
Read RFC 9111 sections on freshness and the Cache-Control directives, then Fastly's caching concepts. Put a Fastly service in front of a small origin (a static site in object storage works) and send repeated curl -I requests. Watch X-Cache, Age and X-Served-By change. Change the origin's Cache-Control and Surrogate-Control headers and note how the edge reacts.
Week 2: VCL and the request lifecycle
Learn what runs in vcl_recv, vcl_hash, vcl_fetch, vcl_deliver and vcl_error. Add VCL snippets through the UI or Terraform rather than replacing the generated VCL. Practise three tasks: redirect /old to /new, normalise a query string to improve the cache key, and send /api/ to a second backend.
sub vcl_recv {
if (req.url.path ~ "^/api/") {
set req.backend = F_api_origin;
}
}
Backend names in VCL depend on what you configured; F_api_origin is a placeholder for a backend named api_origin.
Week 3: purging, surrogate keys and shielding
Make your origin send a Surrogate-Key header and purge one key with the CLI or API. Try a soft purge and confirm that stale content is served while the edge refetches. Enable shielding by choosing a shield POP near your origin and explain why it reduces origin requests.
fastly purge --key product-42 --soft --service-id "$SERVICE_ID"
Week 4: Fastly Compute
Pick one of the official SDK languages: Rust, JavaScript or Go. Create a project, run it locally and publish it. Add a Config Store value and read it from code, then store a token in a Secret Store. Be ready to explain that Compute code is compiled to WebAssembly and runs per request in an isolated sandbox.
fastly compute init
fastly compute serve # local testing
fastly compute publish # build and deploy
Week 5: observability and automation
Configure real-time log streaming to an endpoint you control, such as an object storage bucket or a log platform, with fields for status, cache state, POP and time to first byte. Then move the service into Terraform with the fastly/fastly provider and apply changes from a CI pipeline that validates before it activates. Practise rolling back by reverting a commit.
Week 6: security and design
Read about Fastly's Next-Gen WAF, rate limiting and DDoS protection. Restrict your origin so it accepts traffic only from Fastly, for example with a shared secret header that the origin checks, or by allowing Fastly's published IP ranges. Then rehearse design answers: origin failover, multi-CDN, caching personalised pages and safe rollout of edge code.
How to use the practice questions
These questions are meant to be answered out loud. They avoid the definitions already covered on the freshers and FAQ pages.
Practice questions: freshers
1. Walk me through what happens when a browser requests a page served by Fastly.
DNS resolves the hostname to Fastly, the browser connects to a nearby POP and completes TLS, Fastly builds a cache key and checks cache. On a hit it responds; on a miss it fetches from the backend, applies caching rules and responds.
2. Why would you set different TTLs for the CDN and the browser?
You can purge the CDN but not browsers. A long edge TTL with a short browser TTL keeps the origin quiet and still lets users get updates soon after a purge.
3. How would you show that a change to cache headers worked?
Request the same URL twice with curl -I and compare X-Cache and Age, then check the hit ratio graph after some traffic.
4. What would you put in a log line for a CDN request?
Time, client country, POP, URL, status, cache state, bytes, time to first byte and backend name. These let you split errors by POP or backend.
5. What is the risk of caching responses that set cookies?
One user's session cookie could be served to others. Strip the cookie or pass the request, depending on the content.
6. Why is TLS to the backend worth enabling?
Traffic between the POP and the origin crosses the public internet. TLS protects it and lets the origin verify the connection came through your service.
Practice questions: 2 to 5 years
7. How do you design surrogate keys for an e-commerce site?
Tag each page with the IDs of what it shows: product, category, brand. When a price changes, purge the product key and every page with that product updates.
8. How would you test a VCL change before activation?
Validate the version, test it in a staging service that mirrors production, and use Terraform plans in review. Activate during low traffic and watch errors and hit ratio.
9. How do you deploy a Compute service from CI?
Build and run unit tests, run the app locally with the CLI for smoke tests, publish to a staging service, run checks against it, then publish to production with an API token scoped to that service.
10. How do you keep API tokens safe in pipelines?
Use narrowly scoped tokens, store them as CI secrets or in a vault, rotate them and avoid printing them in logs.
11. A backend is slow only for some POPs. How do you confirm it?
Group logs by POP and backend timing. If shielding is on, check whether those POPs route through a shield far from the origin.
12. How would you handle a redirect map with 5,000 entries?
Store it in an edge dictionary (VCL) or Config Store (Compute) and look up the path, so updates do not require code changes.
13. What alert would you set on a Fastly service?
5xx rate above a threshold, a sharp hit ratio drop and origin latency increase. Tie them to the on-call rota and a runbook.
14. How do you avoid cache stampedes after a deploy?
Use soft purges, request collapsing and stale-while-revalidate, and purge by key rather than purging everything.
15. How do you cache an API response that varies by language?
Normalise the Accept-Language header to a short set of supported values and include that value in the cache key or Vary.
16. What would you check if Terraform shows drift on a Fastly service?
Someone may have edited it in the UI. Compare the active version to state, decide which is correct, and import or re-apply so code is the source of truth.
Practice questions: senior
17. Design origin failover with Fastly.
Configure two backends with health checks, route to the primary and fall back when it is unhealthy, and allow stale content on error so users still get pages during the switch.
18. When does a multi-CDN setup make sense?
When a single provider outage is unacceptable or contracts require it. It doubles configuration, logging and purge work, so automation and a traffic steering layer are needed.
19. How would you roll out new Compute code safely?
Deploy to a percentage of traffic or a test hostname first, compare error rates and latency, keep the previous version ready to reactivate and automate rollback triggers.
20. How do you cache personalised pages?
Cache the shared shell and fetch personal parts separately, or vary on a small number of segments rather than on user ID.
21. How would you protect a login endpoint at the edge?
Rate limit by client and path, add WAF rules for credential stuffing patterns, pass the request without caching and alert on spikes.
22. What metrics would you report to leadership about the CDN?
Hit ratio, origin offload, error rate, time to first byte by region and cost per request trends.
Practice questions: scenarios
23. Hit ratio fell sharply after a marketing campaign.
Look for new query parameters such as tracking tags in URLs. Strip or ignore them in the cache key.
24. The origin is overloaded right after a purge.
Switch to soft purges, enable shielding and request collapsing, and serve stale while revalidating.
25. A Compute app returns errors only in production.
Compare configuration: Config Store values, secrets and backend definitions differ between local and production. Check logs for the error and the SDK limits documentation.
26. Users report a certificate warning on one hostname.
Check that the hostname is covered by the certificate on Fastly, that DNS points to the right records and that renewal did not fail.
27. A WAF rule blocks legitimate checkout requests.
Find the rule and request pattern in WAF logs, add a narrow exception, and keep the rule in monitoring mode until false positives stop.
28. A teammate activated a broken version on Friday night.
Reactivate the previous version, confirm recovery, then move changes into Terraform with review so the UI is not the path to production.
Mock interview checklist
- Explain one Fastly lab you built in two minutes: problem, what you configured, result.
- Draw the request path from browser to origin, including DNS, TLS, POP, shield and backend.
- Answer one scenario using symptom, cause, fix and prevention.
- Prepare a question for the interviewer about how the team handles on-call and changes.
- Review incident response basics with our SRE interview preparation guide and compare edge concepts in scenario-based Cloudflare questions.
If you prefer guided practice for the Linux, Terraform and CI/CD parts of this plan, the DevOps training course runs in our Kharadi, Pune classroom and live online. Terraform-specific practice is in the Terraform course.
FAQ
How long does it take to prepare for a Fastly interview?
About six weeks at an hour a day for a fresher, four weeks for a DevOps engineer new to Fastly and two weeks for someone with CDN experience.
Do I need a paid Fastly account to practise?
No. Fastly offers a free account option that is enough for small test services and Compute experiments. Check current limits on Fastly's site.
Should I learn VCL or Compute first?
Start with VCL and HTTP caching, because they explain how Delivery services work. Add Compute in week 4 once caching concepts are clear.
Which language should I use for Fastly Compute?
Use the official SDK language you know best: Rust, JavaScript or Go. Candidate reports for software roles mention Rust, so it helps there.
What does the Fastly interview process look like?
Public candidate reports describe recruiter and hiring manager screens, technical rounds and a final loop. Confirm the format for your role with the recruiter.
Is Terraform needed for Fastly roles?
For DevOps and SRE roles it helps a lot. The official fastly/fastly provider lets you manage services as code and roll back through Git.
Official references
What's Your Reaction?
Like
0
Dislike
0
Love
0
Funny
0
Angry
0
Sad
0
Wow
0