App Engine is one of the older serverless compute options on Google Cloud, and it still shows up on the Professional Cloud Architect exam. The questions tend to focus on two things: how the platform is set up at the project level, and when you would pick App Engine Standard versus App Engine Flexible. This article walks through both.
App Engine is a fully managed Platform as a Service. You hand it your code, point it at a configuration file, and it builds the container, runs the application, and scales it for you. The level of abstraction is higher than Cloud Run. With Cloud Run you bring a container. With App Engine the platform is closer to "give me your code and a YAML file."
It supports multiple languages and frameworks, and the configurability you do get comes through that YAML file rather than through container internals.
There are two setup constraints worth memorizing for the Professional Cloud Architect exam.
First, each Google Cloud project can host exactly one App Engine application. If you need multiple App Engine apps, you need multiple projects. There is no concept of running two App Engine apps side by side inside a single project.
Second, App Engine applications are regional, and the region is permanent. Once you pick a region at creation time, you cannot move the app to a different region later.
The exam scenario you should be ready for is some variation of "our App Engine app needs to run in a different region, what do we do?" The correct answer always involves creating a new project and deploying a new App Engine app in the new region. There is no in-place migration.
Application settings live in a YAML file that you ship with the code. It defines the runtime, environment variables, scaling parameters, and request handlers.
service: my-app
runtime: python39
env_variables:
SECRET_KEY: "my-secret-key"
automatic_scaling:
max_instances: 3
handlers:
- url: /.*
script: auto
The fields do roughly what you would expect. service names the service. runtime selects the language version. env_variables sets environment variables for the app. automatic_scaling controls scaling behavior. handlers defines URL routing rules. You do not need to memorize the YAML for the exam, but you should recognize that this file is where you control deployment, not the console.
App Engine supports automatic scaling, configured in the YAML file. You can set both a minimum and a maximum number of instances.
The exam-relevant detail is the comparison with Cloud Run. Cloud Run scales to zero by default. App Engine does not. App Engine keeps at least one instance running at all times. That gives you instant responsiveness on the next request, but you lose the cost savings you would get from a true scale-to-zero service. If a question contrasts App Engine and Cloud Run on idle cost, that is the distinction being tested.
App Engine has two environments, Standard and Flexible, and the differences across them are the second big chunk of exam material. The cleanest way to hold this in your head is a feature-by-feature comparison.
Standard uses predefined runtime versions. You pick from a list of supported language versions, and the platform optimizes them for performance and scaling. Flexible runs custom Docker containers. If you need a runtime, library, or version that is not on the Standard list, that is a Flexible signal.
Standard offers near-instant autoscaling. New instances spin up fast, which is what you want for unpredictable web traffic. Flexible scales at the instance level and is slower, because you are scaling VMs rather than lightweight runtime sandboxes.
Standard gives you limited customization. You do not get OS-level access, because the environment is highly managed. Flexible runs on VMs and gives you full VM and OS-level access. If a question mentions needing to install custom system packages or tune the OS, that is Flexible.
Standard cannot reach private networks directly. To talk to on-premises systems or other private networks, Standard needs Serverless VPC Access. Flexible has more native networking capability and supports Cloud VPN directly. If the scenario describes connecting an App Engine workload to on-premises systems with the least configuration, Flexible is usually the better fit.
Standard is built for web apps with traffic surges that need fast scaling and minimal customization. Flexible is built for custom applications, often with long-running processes or non-standard runtime requirements.
Standard is cheaper. Flexible is more expensive. That mostly tracks the underlying difference: Standard runs on a managed lightweight environment, Flexible runs on actual VMs.
The App Engine questions on the Professional Cloud Architect exam usually fall into a few patterns.
One is the region-change scenario, which always resolves to "create a new project and a new App Engine app." Another is the App Engine versus Cloud Run idle-cost question, where the key fact is that App Engine does not scale to zero. The third is a Standard versus Flexible decision question, where the discriminator is one of: custom runtime needs, OS-level access, native VPN connectivity, or cost sensitivity.
If you can answer those three patterns confidently, the App Engine portion of the exam is mostly handled.
My Professional Cloud Architect course covers App Engine alongside the rest of the containers and serverless material.
