There are two types of App Engine environments, standard and flexible. The App Engine standard environment is based on container instances running on Google's infrastructure. Containers are pre-configured with a runtime from a standardized list of supported languages and versions, which includes libraries that support App Engine standard APIs. For many applications, the standard environment runtimes and libraries may be all you need. Standard environment features include persistent storage with queries, sorting and transactions, automatic scaling and load balancing, asynchronous task queues for performing work outside the scope of a request, scheduled tasks for triggering events at specified times or regular intervals, and integration with other Google Cloud services and APIs. There are a couple of requirements for using the standard environment. You must use specified versions of Java, Python, PHP, Go, Node.js, and Ruby and your application must conform to sandbox constraints that are dependent on runtime. Applications run in a secure sandbox environment. This allows the App Engine standard environment to distribute requests across multiple servers and scale servers to meet traffic demands. This means that your application runs within its own secure, reliable environment that is independent of the hardware, operating system, or physical location of the server. A standard environment workflow typically follows these three steps. First, a web application is developed and tested locally. Second, the SDK is used to deploy the application to App Engine. Third, App Engine scales and services the application. App Engine also offers a flexible environment. If the standard environment sandbox model is too restrictive for you, the flexible environment can let you specify the type of container your web application will run in. This option lets an application run inside Docker containers on Google Cloud's Compute Engine virtual machines. In this case, App Engine manages Compute Engine machines for you. This means that instances are health-checked, healed as necessary, and co-located with other module instances within the project. Critical backward-compatible updates are automatically applied to the underlying operating system. VM instances are automatically located by geographical region according to the settings in your project. Google's management services ensure that all of our projects' VM instances are co-located for optimal performance. VM instances are restarted on a weekly basis. During restarts, Google's management services will apply any necessary operating system and security updates. The flexible environment supports microservices, authorization, SQL and NoSQL databases, traffic splitting, logging, search, versioning, security scanning, Memcache, and content delivery networks. App Engine flexible allows users to also benefit from custom configurations and libraries while still keeping their main focus on what they do best, writing code. In addition, the App Engine flexible environment allows you to customize the runtime in the operating system of your virtual machine by using Docker files. As an App Engine Standard supported runtimes include Python, Java, Go, Node.js, PHP, and Ruby. However, in App Engine flexible developers can also use different versions of these runtimes or provide their own custom runtime by supplying a custom Docker image or using a Docker file from the open-source community. How do these two environments compare to each other? Let's start with the standard environment, which is fast. It starts up instances of your application in seconds, but you have less access to the infrastructure in which your application runs. But the standard environment, you can't use SSH to connect to the virtual machines on which your application runs and you can't write to a local disk. The standard environment does support third-party binaries for certain languages and you can use App Engine to make calls to the network. Finally, in terms of pricing, after a free tier usage, you pay per instance class with automatic shutdown. The flexible environment takes minutes to startup instead of seconds. But it lets you use SSH to connect to virtual machines on what your application runs. It lets you use local disk for scratch space. It lets you install third-party software, and it lets your application make calls to the network without going through App Engine. In terms of pricing, with the flexible environment, you pay for resource allocation per hour with no automatic shutdown. Because App Engine uses Docker containers, you may be wondering how App Engine compares to Google Kubernetes Engine. App Engine standard environment is for people who want the service to take maximum control of their web and mobile applications deployment and scaling. Google Kubernetes Engine, however, gives the application owner the full flexibility of Kubernetes, App Engine's flexible environment is somewhere between the two.