App Engine and Cloud Functions are both serverless compute options on Google Cloud, and they both remove the burden of managing infrastructure. But they are designed for very different use cases, and mixing them up on the Associate Cloud Engineer exam will cost you points. The distinction comes down to what you are deploying: a full application versus a piece of event-driven logic.
App Engine is a platform-as-a-service offering that lets you deploy and run a full web application or API backend without managing any servers. You write your application, configure a few settings in an app.yaml file, and deploy it with gcloud. App Engine handles capacity provisioning, load balancing, scaling, and health monitoring automatically.
App Engine is designed for applications that receive HTTP traffic and need to stay running, handling requests as they come in. A web application, a REST API, an admin backend - these are the right kinds of workloads for App Engine. It supports multiple languages including Python, Java, Node.js, Go, Ruby, and PHP, and each language runtime has a well-defined deployment model.
There are two App Engine environments to know. The Standard environment runs code in a sandboxed container with specific language runtimes and scales to zero when there is no traffic - useful for workloads with unpredictable or bursty traffic where you want to pay nothing during idle periods. The Flexible environment runs code in a Docker container on Compute Engine VMs, supports any language, and provides more flexibility in terms of what libraries and system packages you can use, but it does not scale to zero and is more expensive at low traffic levels.
Cloud Functions is a serverless execution environment for individual functions. You deploy a single function - a piece of code that does one thing - and Cloud Functions runs it in response to a trigger. The trigger could be an HTTP request, a message published to a Pub/Sub topic, a file uploaded to Cloud Storage, a Firestore document change, or several other event types.
Cloud Functions is priced per invocation and per compute time. When the function is not running, you pay nothing. This makes it extremely cost-efficient for workloads that are triggered sporadically rather than running continuously. A function that processes uploaded files might run a thousand times a day during business hours and zero times overnight - that usage pattern would be wasteful on App Engine but is natural for Cloud Functions.
The main difference between App Engine and Cloud Functions is scope. App Engine hosts an entire application with multiple routes, middleware, request handling logic, and state management. Cloud Functions hosts a single function that handles a single type of event.
Another difference is trigger type. App Engine is always HTTP-based - it handles incoming web requests. Cloud Functions can be triggered by HTTP but also by dozens of other event sources, including GCP service events like Pub/Sub messages and Cloud Storage uploads. If the trigger is anything other than an HTTP request, Cloud Functions is the more natural choice.
Complexity is also a distinguishing factor. If your code has routing logic, handles multiple types of requests, uses multiple libraries, and has significant shared state or session management, App Engine makes more sense because it is designed for that kind of application structure. If your code does one thing in response to one type of event, Cloud Functions is simpler and cheaper to operate.
App Engine works well for: customer-facing web applications, internal tools and dashboards, REST APIs that serve mobile or web clients, and scheduled batch jobs using the App Engine Cron Service.
Cloud Functions works well for: processing files after they land in Cloud Storage, transforming or routing Pub/Sub messages, sending notifications or webhooks in response to database changes, lightweight API endpoints that handle a single operation, and any integration glue code that runs in response to GCP service events.
The Associate Cloud Engineer exam presents these two services in scenario-based questions where you need to pick the right compute option for a described workload. The scenario will give you clues.
If the workload is described as a web application, an API that serves multiple types of requests, or something that developers want to deploy with minimal infrastructure configuration, App Engine is usually the answer. If the workload is described as something that runs in response to an event - a file upload, a Pub/Sub message, an HTTP webhook - Cloud Functions is usually the answer.
The exam also distinguishes between App Engine and other options like Cloud Run and Cloud Functions. Cloud Run is similar to App Engine but containerized - it gives you more control over the runtime environment at the cost of needing to manage a Dockerfile. If a scenario mentions containers, Cloud Run is the more specific answer. If a scenario mentions a simple web app or API without container requirements, App Engine Standard is often the right pick because of its simplicity.
My Associate Cloud Engineer course covers App Engine and Cloud Functions in the compute section, including how to distinguish between them, Cloud Run, and Compute Engine in the scenario-based questions on the Associate Cloud Engineer exam.
