Google App Engine Reviews

In my current company, my client is completely based on Google. They are using their domain from Google and mixing Google Cloud with AWS Cloud. When it comes to deploying our microservices or REST APIs over the cloud, I develop APIs and portals for the Service Request Development (SRD) team. There are a lot of SRD personnel involved, possibly around 1K users, with many leaders using the services globally due to my engagement with a major IT giant.

The features of Google App Engine are very valuable, as it is the same as in AWS, Beanstalk, and in Azure, where it operates similarly. Google App Engine is a complete PaaS, platform as a service. Here, we are provided two types of scaling; if we are on a standard use case, we are provided basic and automatic and manual options, and if we are on flexible users, we have access to all three types. Google App Engine is fully managed, meaning users don't need to manage resources themselves; however, management is required and is handled by Google. For the standard environment, there are two variants: the standard and the flexible environment. The standard environment works a sandbox, whereas in the flexible environment, when we click on create, it starts its VM and initializes its virtual disk and resources, which we can access using the VM. In the case of the standard environment, we can't access all the other resources.

I've noticed measurable benefits and return on investment by choosing Google App Engine. The deployment process is managed by Google, allowing me to focus on selecting our language and uploading our code, while Google manages everything else—including the provision of the VPC for flexible deployments. If choosing the flexible option, it automatically creates a VPC, whereas for standard, no VPC is provided. Essentially, I only need to make minimal choices regarding regions; other than that, I focus solely on how my code operates.

My usual use case for Google App Engine is related to SaaS applications where we create applications. For this purpose, we needed Google App Engine. We had concluded between AWS, Google GCP, and Microsoft Azure. At that particular time, we decided to use GCP because of the cost effectiveness and the support. We had a tie-up with Google for that particular application.

The scalability impacts my customer's experience with Google App Engine because our system, which we designed, is microservice-based and must be scalable. We are handling around billions of data, so if the load is not scalable, then it cannot take the load we expected. We are scaling accordingly; when the CPU is already 60% full, we scale to another CPU on other Google App Engines. According to that configuration, we have around 16 to 70 systems for per single use instances.

I deployed a Python Flask-based API on Google App Engine using Firestore for real-time data storage. The platform's autoscaling capabilities allowed the apps to handle any increase in traffic without manual intervention. I also leveraged Cloud Pub/Sub for background processing tasks, ensuring smooth performance. Additionally, I used Stackdriver to monitor logs and identify optimization areas, making the deployment more efficient.

The zero infrastructure management is valuable, allowing me to focus on the code rather than the service. The solution offers scalability, autoscaling based on user demand, and security, as Google manages all updates and security patches. Integration with Google Cloud Platform works well with all Google Cloud services. It offers flexible development options with multiple programming languages.

My use cases involved writing scripts to connect with Google Spreadsheets, Google Docs, and Gmail APIs, available in the Google App Engine Script engine. I customized tasks, data displays, and email templates. For instance, I worked with a procurement tool to get invoices and attach them to Gmail or display custom HTML templates in emails. This integration is primarily with our product and the customers' domains. It required writing code to fetch data, create templates, and populate them with different designs.

Google App Engine's APIs are easily accessible within Google. The API reference site provides clear explanations on how to perform actions within spreadsheets or documents, showing functions and examples. Deploying code is straightforward without worrying about deployment or integration. You create a new sheet or program and write in JavaScript, making it user-friendly for developers.

I used Google App Engine about 10 months ago. We used it to deploy frontend services and backend services. We deployed through Google App Engine using both the standard environment and the flexible environment for different end services.

Regarding integration capabilities, there were Google credentials features that made it easy to use other services from Google, such as Pub/Sub messaging service and other functionalities, which were very tightly integrated. I did not have to think about the authentication between the services as it was seamless, and I did not have to do any extra work to get the authentication part working.

We were using approximately five or six services with Google App Engine, including three backend services and a couple of frontend services. Some of them used Google's Pub/Sub messaging service and Google's Maps APIs.

What I really appreciated about Google App Engine was how simple it was to spin up new services. It took care of most tasks that would typically require manual setup when configuring a server. It functioned almost as a serverless solution.

Another beneficial aspect was the ease of creating new versions of the application. If I had a production version and wanted to experiment with something else, it was straightforward to create a new version from the command line, deploy it on Google App Engine, and use it as a different environment.

The auto-scaling feature that Google App Engine provides was particularly useful as we never had to manage how the app was scaling. We never experienced any downtimes, which demonstrates the effectiveness of the scaling capability.

The auto-scaling feature helped us significantly in our fast-paced environment where the number of users was increasing rapidly. We could improve latency for users in two ways: optimizing the application code ourselves, which we did when possible, and allowing Google to scale our services as needed. This helped us focus on fixing bugs and adding new features rather than deep optimizations.

Operationally, it was efficient because we could easily spin up new versions to demonstrate new functionality without modifying the original environment. Not having to maintain the server ourselves or worry about scaling were valuable benefits we appreciated.

I use Google App Engine primarily for deploying front-end applications with server-side rendering. I have multiple front-end applications deployed in React and Next.js, and I use Google App Engine for server-side front-end rendering.

The most valuable features of Google App Engine include the ease of rolling back deployments when failures occur, the ability to track deployment times, and the feature to split traffic between different instances. I also appreciate the Google App Engine standard environment because it handles traffic scaling without manual intervention.

I am a Java developer and primarily use Google App Engine for UI-based applications and hobby projects. I have used it for various applications, including CRM kind of applications. I test and create apps, primarily focusing on these use cases for my personal projects.

What I find most valuable about Google App Engine is its support for open-source development. It is not difficult to get into, which is a great advantage. The solution provides a lot of statistics about performance, such as read and write metrics by default. It helps with managing applications through inbuilt APIs and log monitoring. The scalability aspect is very well-designed, so I do not have to worry about disk space and scaling configurations. It also scales beautifully, which is impressive. Google App Engine offers a cloud-based solution for free, especially for Java, making it a cost-effective option compared to expensive VMs.

I use the solution in my company to deploy web applications.

The most valuable features of the solution stem from the fact that it can be easily deployed and run on our company's server.