Cloud Compute Options and Trade-offs Questions
Choosing among compute abstractions independent of provider: virtual machines, containers, managed container services, serverless functions, and bare metal. Covers the cost, control, cold-start, scaling, and operational trade-offs of each model; how to pick an instance family or hardware accelerator (general-purpose, compute-optimized, memory-optimized, GPU, TPU) and a purchasing model (on-demand, reserved, spot); and how workload characteristics (latency, statefulness, burstiness) drive the decision. Managed-versus-self-managed reasoning lives here.
Compare cost for two deployment options given this workload: 1,000,000 requests per day with a 1-hour peak at 3,000 requests per second, average execution time 200ms, and 512MB memory per serverless invocation. The alternative is a managed container platform running 3 replicas sized at 0.5 vCPU and 1GB memory each behind a load balancer. Walk through how you'd estimate monthly cost, what additional operational costs to account for, and what non-price factors would influence the final recommendation.
Sample Answer
Direct answer
Before running any numbers, the two traffic figures given don't reconcile: a full hour sustained at 3,000 requests per second is 10.8 million requests, almost eleven times the stated 1,000,000 requests/day total. In a real estimate that's the first thing to flag back to whoever supplied the numbers, since the answer changes by an order of magnitude depending on which figure is authoritative. To give a usable answer anyway, I'll use the 1,000,000/day total (the number that actually drives billed cost for both options) for the cost estimate, and treat "3,000 requests/second for an hour" as the capacity target the infrastructure must survive, which is a separate, non-price question. On the cost math alone, the serverless option comes out cheaper here (about $56/month versus about $70/month for the container option), but the container option as specified is very likely undersized for the stated peak, which matters more than the 20% cost gap.
Structured elaboration
Serverless (function-as-a-service, FaaS) cost model: billed per invocation plus per GB-second of memory times duration.
monthly GB-seconds=(requests/day×30)×(memory GB×duration s)Using 1,000,000 requests/day, 512MB (0.5GB), 200ms, and current public list pricing for a major FaaS platform ($0.0000166667/GB-second, $0.20 per million requests) as a concrete, verifiable reference point:
- Monthly GB-seconds: 1,000,000×30×0.5×0.2=3,000,000
- Compute cost: 3,000,000×0.0000166667≈$50.00
- Request cost: 30,000,000/1,000,000×$0.20=$6.00
- Total: about $56/month
Managed container cost model: billed per vCPU-hour and GB-hour for whatever is provisioned, whether it's busy or not.
Using the given 3 replicas at 0.5 vCPU / 1GB, run continuously (a fixed fleet doesn't turn itself off), and current public list pricing for a comparable managed-container-per-task platform ($0.04048/vCPU-hour, $0.004445/GB-hour):
- vCPU-hours/month: 3×0.5×24×30=1,080; cost ≈$43.72
- GB-hours/month: 3×1×24×30=2,160; cost ≈$9.60
- Plus a load balancer in front of the replicas, roughly $16/month baseline
- Total: about $69.32/month
Additional operational costs neither number above includes: structured logging and tracing ingestion (30 million invocations a month generates a lot of log volume, and per-GB log-ingestion pricing on an observability platform can rival the compute bill if every invocation logs verbosely); a NAT gateway (a managed component that lets resources without a public IP address reach the internet) if the containers sit in a private subnet (a network segment with no direct path to the public internet) and call external services (hourly plus per-GB-processed charges that are easy to forget when only pricing compute); container image registry storage and CI/CD minutes; and, on the serverless side, provisioned concurrency if cold starts turn out to be unacceptable, which keeps a set number of execution environments pre-initialized and adds a standing cost on top of the per-invocation price, partially eroding the serverless cost advantage (reserved concurrency is a different, unrelated lever: it caps and guarantees a slice of the account's concurrency limit for this function specifically, but it does not pre-warm anything, does not address cold starts, and costs nothing extra beyond the same per-invocation and duration charges already priced above).
Worked example: is the container fleet even sized correctly for the peak
Taking the 3,000 requests/second peak literally as a capacity requirement (regardless of which daily total is right): by Little's law (a queueing-theory identity: the average number of things in progress at once equals the rate they arrive times how long each one takes to finish), concurrent in-flight requests needed is 3,000×0.200s=600. Spread across 3 replicas that's 200 concurrent requests per replica, on only 0.5 vCPU each. That's plausible only if the workload is I/O-bound (mostly waiting on a downstream call, so one core can juggle many concurrent connections on an async runtime) and implausible if it's CPU-bound (200 concurrent CPU-bound requests cannot be served by half a core no matter the runtime). The question doesn't say which, and that single fact changes the real answer more than the raw cost comparison does: if CPU-bound, the "3 replicas" figure is a floor that must autoscale well beyond 3 during the peak hour, which raises the container bill above the $69.32 estimate above and could flip the recommendation either way depending on how much the peak fleet actually needs to grow.
Trade-offs and pitfalls
- Recommendation: given the total volume is modest (1,000,000/day) and there's a well-defined 1-hour peak against an implied low background rate the rest of the day, that traffic shape is exactly what per-invocation billing is suited for. I'd recommend serverless, on the condition that the team checks headroom on the platform's concurrency quota ahead of the peak. AWS Lambda's default regional concurrent-executions quota, for example, is 1,000, which comfortably covers the 600 concurrent executions this peak requires on its own, but that quota is shared across every function running in the same account and region, so a burst in an unrelated function during the same window can still exhaust it, and a newly created account can start with a lower, usage-scaled quota that the provider raises automatically over time. The team should confirm current utilization against that shared ceiling rather than assume 600 is automatically safe, and accept a bounded amount of cold-start latency risk, mitigated with a small amount of provisioned concurrency if the 200ms average execution time makes cold starts user-visible.
- What would flip it: if the workload is genuinely CPU-bound at that concurrency, the container option's real cost (after the autoscaling correction above) could exceed the naive estimate enough to erase the serverless price advantage, and control over the runtime (custom system dependencies, long-lived connections to a downstream database) would tip the decision toward containers regardless of price.
- The bigger pitfall in this whole exercise: computing confidently from numbers that don't agree with each other. A senior engineer reconciling a stakeholder's traffic estimate before committing budget to it is the actual skill being tested here, not producing a single dollar figure.
Describe the main autoscaling approaches available for cloud compute: horizontal autoscaling (of pods or instances), vertical scaling, scheduled scaling, and predictive autoscaling. For each approach, explain typical use cases, benefits, and the pitfalls it can introduce in production.
Sample Answer
Direct answer
There are four main ways cloud compute scales: horizontal autoscaling (adding or removing instances or pods), vertical scaling (resizing an existing instance or pod), scheduled scaling (changing capacity at known times), and predictive autoscaling (forecasting demand from historical patterns and scaling ahead of it). They aren't mutually exclusive: most mature systems combine horizontal scaling as the default mechanism with scheduled or predictive scaling layered on top to compensate for the lag horizontal scaling can't avoid.
Structured elaboration
| Approach | How it works | Best fit | Pitfall it introduces |
|---|---|---|---|
| Horizontal autoscaling | Add or remove replicas (instances, pods, or function concurrency) in response to a metric like CPU utilization, queue depth, or request rate | Stateless services with roughly linear per-replica capacity; the default choice for web tiers and APIs | Scale-out lag: a new replica has to boot, warm up, and pass a readiness check before it can take traffic, so a sharp spike still causes a window of overload before capacity catches up. It also silently assumes the workload is stateless, if it isn't, adding replicas doesn't add usable capacity |
| Vertical scaling | Resize the CPU/memory of an existing instance or pod (or a Kubernetes Vertical Pod Autoscaler adjusting requests/limits) | Single-instance workloads that can't be easily distributed (a monolith with in-memory caching, a stateful database primary) or right-sizing chronically over- or under-provisioned pods | Almost always requires a restart to apply, so it can't respond to a live spike; it also has a hard ceiling, the largest instance size in the family, after which you must re-architect regardless of budget |
| Scheduled scaling | Pre-set capacity changes tied to a calendar (scale up before a known 9am traffic ramp, scale down overnight) | Traffic with a reliable, human-understood rhythm: business-hours SaaS traffic, a nightly batch window, a known marketing-campaign launch time | It only knows what you tell it. Any deviation from the assumed schedule (a flash sale that lands outside the pre-scaled window, a holiday that breaks the usual weekday pattern) leaves you exactly as exposed as having no autoscaling at all |
| Predictive autoscaling | A model trained on historical load forecasts near-term demand and scales ahead of it, so new capacity is already warm when the spike actually arrives | Workloads with enough historical signal and gradual-enough traffic curves that a forecast has time to act on, recurring but not perfectly calendar-based load | It's only as good as the history it was trained on: a genuinely novel event (a product launch, a viral spike, a first Black Friday) has no precedent in the training data, so the model under-forecasts exactly when you need it most, and a noisy or misconfigured model can also over-trigger, causing cost-wasting scale-up/scale-down thrashing |
Worked example
Take a Kubernetes Horizontal Pod Autoscaler (HPA) targeting 70% average CPU utilization, currently running 3 pods:
- Traffic doubles. Average CPU crosses 70%, the HPA computes a new desired replica count and requests more pods, say scaling toward 6.
- Each new pod needs to be scheduled onto a node (if there's capacity), pull its container image if it isn't cached, start the process, and pass its readiness probe. If that pipeline takes 45 seconds end to end and traffic doubled in 15 seconds, there's a 30-second window where the existing 3 pods are absorbing load meant for 6, likely with elevated latency or dropped requests.
- Layering scheduled scaling on top (if this spike happens at a known daily peak, pre-scale to 5 pods 10 minutes beforehand) removes that 30-second gap entirely for the known case, while horizontal autoscaling still handles the unknown residual variance around it. That combination, not either mechanism alone, is what most production systems actually run.
Trade-offs and pitfalls
- Horizontal autoscaling only helps if the workload can actually be replicated; a service holding local, unshared state (an in-memory cache with no replication, a long-lived stateful connection) needs to externalize that state first, or scaling out just multiplies inconsistent copies of it.
- Aggressive scale-in policies save money but risk oscillation: scaling down too eagerly right after a scale-up, then scaling back up seconds later as the same traffic returns. A stabilization window (only scale in if the metric has stayed low for several minutes) trades a little cost for a lot of stability.
- Vertical and horizontal scaling solve different problems and are sometimes used together (vertically right-size a pod's per-replica footprint, then horizontally scale the number of replicas), not as competitors.
- Predictive autoscaling adds real operational cost of its own: someone has to own model retraining, drift detection, and a fallback path for when the forecast is simply wrong, it's not a "set and forget" layer on top of the simpler mechanisms.
Create a decision framework to help choose a compute option for a given workload: identify the criteria that matter and how you'd weight them, then demonstrate how you'd score and rank the options for five example workloads: a batch-processing job, a web API, a high-throughput streaming pipeline, an ML training job, and a low-latency trading system.
Sample Answer
Direct answer
A decision framework needs two separate things: a fixed set of criteria with scores that describe each compute option's inherent properties (these don't change based on the workload), and a set of weights that describe how much this particular workload cares about each criterion (these change every time). Multiplying and summing the two gives a ranked, reproducible score per workload, and it also exposes the framework's own limits: for at least one of the five workloads below, no option in the matrix wins outright, which is itself useful information.
Structured elaboration
Criteria (properties of the compute option itself, scored 1 to 5, higher is better for that property):
latency: how well the option delivers low, consistent latency (no cold starts, dedicated capacity)burst_idle: how well the option avoids paying for idle capacity under bursty or low-utilization loadlong_duration: how well the option supports long-running or unbounded executionstatefulness: how well the option supports persistent local state or specialized hardware accesscontrol: how much kernel/hardware/network/compliance customization the option allowsops_simplicity: how much day-to-day operational burden the option removes from the team
| Option | latency | burst_idle | long_duration | statefulness | control | ops_simplicity |
|---|---|---|---|---|---|---|
| Virtual machine (VM) | 5 | 1 | 5 | 5 | 5 | 1 |
| Self-managed containers (you run the orchestrator) | 4 | 2 | 5 | 4 | 4 | 2 |
| Managed container service | 3 | 3 | 4 | 3 | 2 | 4 |
| Serverless functions (FaaS) | 2 | 5 | 1 | 1 | 1 | 5 |
Weights (how much each workload cares about each criterion, summing to 1.00 per workload):
| Workload | latency | burst_idle | long_duration | statefulness | control | ops_simplicity |
|---|---|---|---|---|---|---|
| Batch-processing job | 0.05 | 0.30 | 0.30 | 0.05 | 0.05 | 0.25 |
| Web API | 0.25 | 0.20 | 0.05 | 0.10 | 0.10 | 0.30 |
| High-throughput streaming pipeline | 0.15 | 0.05 | 0.25 | 0.25 | 0.20 | 0.10 |
| Machine learning (ML) training job | 0.00 | 0.10 | 0.25 | 0.15 | 0.35 | 0.15 |
| Low-latency trading system | 0.55 | 0.00 | 0.05 | 0.15 | 0.25 | 0.00 |
Weighted score per option per workload is ∑cweightc×scorec.
Worked example
Fully worked for the web API row (weights: latency .25, burst_idle .20, long_duration .05, statefulness .10, control .10, ops_simplicity .30):
- VM: 0.25(5)+0.20(1)+0.05(5)+0.10(5)+0.10(5)+0.30(1)=3.00
- Self-managed containers: 0.25(4)+0.20(2)+0.05(5)+0.10(4)+0.10(4)+0.30(2)=3.05
- Managed container service: 0.25(3)+0.20(3)+0.05(4)+0.10(3)+0.10(2)+0.30(4)=3.25
- Serverless: 0.25(2)+0.20(5)+0.05(1)+0.10(1)+0.10(1)+0.30(5)=3.25
Managed container service and serverless tie for the web API, both ahead of the two self-operated options, which matches intuition: a typical web API doesn't need deep hardware control, and the ops-simplicity weight rewards both managed options roughly equally.
Applying the same arithmetic to all five workloads:
| Workload | VM | Self-managed containers | Managed container service | Serverless | Winner |
|---|---|---|---|---|---|
| Batch-processing job | 2.80 | 3.20 | 3.50 | 3.25 | Managed container service |
| Web API | 3.00 | 3.05 | 3.25 | 3.25 | Managed container service / Serverless (tie) |
| Streaming pipeline | 4.40 | 3.95 | 3.15 | 1.75 | Virtual machine |
| ML training job | 4.00 | 3.75 | 3.05 | 2.00 | Virtual machine |
| Trading system | 5.00 | 4.05 | 2.80 | 1.55 | Virtual machine (in-matrix) |
For batch and web API, a managed option wins because ops simplicity and cost-under-idle dominate the weighting and neither workload needs deep hardware control. For streaming and ML training, the virtual machine wins in this four-option matrix because control and statefulness carry heavy weight and no managed option matches a VM's ability to pin hardware or hold long-lived local state, though in practice a well-configured self-managed container platform (a close second in both rows) is the more common real choice once you also weigh the ops cost of a full VM fleet, a factor this simplified model under-counts.
The trading system is where the framework shows its own limit: even the top scorer here, the VM, is answering the wrong question. At the latency and control extreme this workload demands (kernel-bypass networking, guaranteed no noisy neighbors, deterministic hardware placement), the real answer is a fifth option outside this matrix entirely: dedicated bare-metal hardware. A good framework should surface exactly this kind of gap rather than force-fit every workload into whatever four columns happen to be in the table.
Trade-offs and pitfalls
- The weights are the part of this framework that should come from the team, not from a generic table; a different organization's tolerance for cost-under-idle or its actual bench strength for running infrastructure changes every row.
- The most common wrong turn on this kind of question is presenting only the criteria list without ever producing a number; a framework that can't rank anything isn't a framework, it's a checklist.
- Ties (like the web API row) are a legitimate output, not a failure of the model. When two options tie, the deciding factor becomes something the table doesn't capture, existing team expertise, vendor relationship, or which platform the rest of the org already standardizes on.
You're designing an event-driven pipeline on a serverless (FaaS) platform that must absorb sudden bursts of events. Cold-start latency and the provider's per-account concurrency limits are causing dropped or delayed processing during spikes. Design an architecture that keeps end-to-end latency low and processing reliable under these constraints, and explain how you'd validate that your design actually holds up under a realistic burst.
Sample Answer
Direct answer
Put a durable buffer, a queue, between the burst source and the serverless compute so the function layer is decoupled from the burst's instantaneous shape, then pull from that queue in controlled batches at a rate the function fleet's real concurrency, after warm-up, can sustain. That single move converts "must instantly absorb a huge traffic spike" into "must eventually drain a queue," a fundamentally easier reliability problem, and it's the first thing to check before reaching for any cold-start mitigation.
Is serverless even the right call here
Before mitigating, check whether the burst ratio and reliability bar actually fit the function-as-a-service model at all. If bursts are extreme and frequent, spanning something like 10 requests per second at baseline up to 100,000 at peak, and the workload can tolerate being processed asynchronously rather than needing an immediate synchronous response, a queue-fronted serverless design is a good fit. If instead the workload is synchronous and latency-critical at that same burst ratio, a hybrid design, a small always-on container fleet handling the synchronous path with serverless reserved for genuinely bursty asynchronous work, may be the honest answer rather than forcing everything through functions.
Architecture
flowchart LR
SRC[Burst event source] --> Q[(Durable queue or stream)]
Q --> CONS[Batch consumer]
CONS --> FN[Function fleet: warm baseline plus burst scale-out]
FN -->|failure, retried N times| DLQ[(Dead-letter queue)]
EDGE[Edge cache] -.absorbs repeat requests.-> SRC
MON[Observability: queue depth, oldest-message age, cold-start ratio] -.watches.-> Q
MON -.watches.-> FN
- Ingestion. Events land in a durable queue or stream immediately, decoupling arrival rate from processing rate.
- Batching and controlled pull. Consumers pull events in batches sized to amortize per-invocation overhead and keep the function fleet's concurrency within a range it can serve without every batch triggering a fresh cold start.
- Provisioned concurrency and warm pools. Maintain a baseline of pre-warmed function instances sized to the sustained baseline load, so normal traffic never cold-starts, and let true bursts scale beyond that baseline into on-demand cold instances, so only the burst's leading edge pays the cold-start cost.
- Retry and backoff with a dead-letter queue. A dead-letter queue is a separate queue that catches messages which repeatedly fail processing, so they don't block or silently vanish. Failed invocations retry with exponential backoff up to a bounded attempt count, then land in the dead-letter queue for offline inspection and replay, so one bad message or a downstream outage doesn't stall the whole pipeline.
- Graceful degradation. Define an explicit degraded mode for extreme overload, such as shedding the lowest-priority event types first or falling back to a cheaper, approximate processing path, rather than letting concurrency limits produce undifferentiated dropped or delayed processing across everything.
- Edge caching and a hybrid architecture. Where a meaningful fraction of burst traffic is repeat or cacheable, an edge cache in front of the pipeline absorbs that fraction before it reaches the function layer, directly cutting the burst the serverless tier has to handle. Where a synchronous, latency-critical slice of traffic can be identified separately, route it to a small always-on container fleet instead of serverless, keeping serverless for the genuinely bursty, asynchronous remainder.
- Backpressure at extreme ratios. At a very large burst ratio, per-account concurrency limits will bind well before raw infrastructure does. The queue turns "requests rejected or dropped at the concurrency ceiling" into "requests wait in a monitored backlog," so backpressure becomes queue-depth and processing-lag management: alert on queue depth and the age of the oldest unprocessed message, not just error rate, and autoscale the consumer's batch pull rate against those signals. Pair this with production-incident observability, meaning dashboards and alerts on queue depth, dead-letter arrival rate, cold-start ratio, and end-to-end processing lag, so an operator sees a growing backlog as it develops rather than only after it causes a downstream failure.
Validating the design
Before trusting this in production, run a load test that reproduces the stated burst shape, ramping from the 10 requests-per-second baseline to the 100,000 requests-per-second peak over a realistic ramp time rather than an instantaneous step, unless the real burst genuinely is a step function. Measure queue depth over time, end-to-end processing lag at the tail (the 95th or 99th percentile, not the average), dead-letter arrival rate, and cold-start ratio during the ramp. A design that keeps processing lag bounded and dead-letter arrivals near zero under that reproduced burst is validated. One that shows unbounded queue growth means the consumer's sustained throughput, not just its instantaneous burst absorption, is under-provisioned, which is a capacity fix, not a cold-start fix.
Trade-offs and pitfalls
The most common pitfall is mitigating cold starts through provisioned concurrency and warm pools while leaving the ingestion path synchronous and un-queued, which does nothing for the actual failure mode at extreme scale, since per-account concurrency limits, not cold starts alone, are what drop requests at that point. A second is treating the dead-letter queue as solved once messages land there; a dead-letter queue nobody monitors or replays is just a slower way to lose data, so alert on its arrival rate and maintain an explicit replay process. A third is load-testing only the average traffic level and never the actual burst ramp, which is precisely the scenario this design exists to survive; validate against the worst case named in the requirement, not the typical case.
For a legacy monolith currently running on VMs, compare a lift-and-shift to containers against rearchitecting to serverless microservices. For each approach, sketch a migration plan with phases, expected timelines, key risks, a testing strategy, and the metrics you'd use to decide which path to pursue.
Sample Answer
Direct answer
Lift-and-shift to containers is the lower-risk, faster path, since it repackages the same monolith's process into a container image without changing its architecture. Rearchitecting to serverless microservices is a much larger, slower undertaking that only pays off if the monolith's actual pain points, such as deployment coupling or the inability to scale one hot code path independently, are the kind serverless microservices actually solve. Default to lift-and-shift first, and treat a full serverless rearchitecture as an incremental decomposition done afterward, not a one-shot replacement of the original monolith.
Two migration plans
Lift-and-shift to containers.
Phases: containerize the monolith as-is, with no code changes, using a container definition that wraps the existing runtime and dependencies; validate parity in a staging environment against the current deployment, using the same configuration and data access; run both in parallel behind a router, shifting a small percentage of traffic to the container path; ramp to full traffic on containers, then decommission the old servers.
Timeline: typically the shortest of the two, since no application logic changes; mostly bounded by how much undocumented, environment-specific configuration has accumulated on the old servers over time, since a container has to reproduce that explicitly.
Key risks: hidden environment dependencies, such as files or state baked onto local disk that the monolith silently relies on and that a fresh container doesn't have on first boot; a server that's been running unmodified for a very long time can be masking bugs that containerizing suddenly exposes.
Testing strategy: parity testing, comparing container responses against the existing deployment's responses for the same inputs, plus a load test at expected peak before cutting traffic over, since containers may be scheduled differently, packed onto shared hosts, than a dedicated server was.
Rearchitect to serverless microservices.
Phases: identify seams along real bounded contexts in the business logic, not arbitrary file boundaries; strangle the monolith incrementally, extracting one bounded context behind an application programming interface and routing selected traffic to the new service while the monolith still serves the rest; repeat extraction context by context; retire monolith code paths once each is fully replaced.
Timeline: much longer, proportional to the number of bounded contexts and the amount of shared data coupling between them; realistically measured in multiple quarters or longer for a nontrivial monolith, not weeks.
Key risks: distributed-system failure modes that didn't exist in a single process, such as partial failure between services, data consistency across service boundaries, and added network latency per call; underestimating shared-database coupling is the most common trap, since modules that look separable in code are rarely separable in data without real migration work.
Testing strategy: contract testing between an extracted service and everything that calls it, plus running the old and new code paths side by side with shadow traffic or a feature-flag split, diffing outputs before fully cutting over each extracted piece one bounded context at a time.
Deciding which path to pursue
Weigh how much of the current pain is deployment or packaging friction, which favors lift-and-shift, against a genuine need for independent per-component scaling or team autonomy, which favors decomposition. Weigh the cost of the monolith's current failure mode: if a slow release cycle is costing real velocity now, lift-and-shift buys relief in weeks, while a full rearchitecture buys nothing until each piece ships. Consider team size and organizational fit, since a single small team gets little organizational benefit from microservices regardless of the technical case. And check actual bounded-context clarity in the codebase: if you can't name today where one module ends and another begins, that's a signal the codebase isn't ready for decomposition, independent of any traffic argument.
Trade-offs and pitfalls
The most common pitfall is choosing the serverless microservices rearchitecture because it's the more fashionable answer, rather than because the monolith's actual constraint is one serverless solves; a monolith with steady, predictable traffic and no scaling pain gains nothing from microservices except added operational complexity. The second is treating the container lift-and-shift as a stepping stone that hasn't really finished the job, when for teams whose real problem was deployment friction rather than architecture, it's a valid, complete answer on its own. Run lift-and-shift first regardless of the eventual target, since it de-risks the environment and dependency unknowns cheaply and buys time to do the decomposition analysis properly, rather than under incident pressure.
Unlock Full Question Bank
Get access to all 40 Cloud Compute Options and Trade-offs interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.