Skitsanos Design

I also come from a time when ColdFusion was a thing; the one you've mentioned is almost 20 years old—it should already be a sign for you.

I would definitely go with Flask; here are some key reasons why Flask is a better choice than ColdFusion for this simple CRUD application:

Flask is a modern Python web framework actively maintained and supported by many developers. On the other hand, ColdFusion is an older technology that is less widely adopted or actively developed.

Flask is a lightweight, minimalistic Python web framework that is easy to learn and set up, especially for small projects like this one.

Cross-Platform and Language: Flask is a Python-based framework, making it cross-platform and compatible with multiple operating systems. ColdFusion, being a proprietary Adobe product, is primarily focused on Windows environments.

Flask is an open-source framework and doesn't require any licensing fees, making it a cost-effective solution. ColdFusion, however, comes with a significant upfront cost for licensing, which may not be justifiable for a modest application with only a few users.

While the current application is small, Flask offers better scalability options if the project grows in the future. With its modular design and the vast ecosystem of Python libraries, Flask can be extended and scaled more easily than ColdFusion.

Python and Flask have a larger developer community and a wealth of learning resources, making finding support, hiring developers, and accessing third-party libraries and tools easier. ColdFusion has a relatively smaller community and fewer resources available.

Flask integrates well with modern technologies and tools, such as containerization (Docker), cloud platforms (AWS, GCP, Azure), and data stores (SQL and NoSQL databases). This makes it easier to adopt modern development practices and architectures.

By choosing Flask and Python, the client is investing in a modern and actively developed technology stack that is less likely to become obsolete or unsupported in the future. This ensures better long-term maintainability and extensibility.

If you want to play with Flask, you can grab my template from https://github.com/skitsanos/flask-dynamic-routes. It covers API endpoints and web app pages. You just modify/add your own endpoint handlers on the /routes folder where each HTTP method is represented with relevant files, like get.py, post.py, and so on. It also shows you how to use path parameters and a basic login functionality already implemented to showcase how to use sessions.

I spent years and years with Eclipse, and did VS Code as well, but nothing can compare with JetBrain's line of products. I have been coding since 1992, so I have a long list of IDEs I had my hands on, including developing a couple of IDEs of my own.

JetBrains IntelliJ IDEA stands out as a superior choice for Java programmers compared to Eclipse or Visual Studio Code for several compelling reasons. Firstly, IntelliJ IDEA's intelligent code editor significantly enhances productivity by offering advanced code navigation and comprehensive refactoring support. This intelligence extends to real-time code analysis, which can detect potential errors and suggest fixes as you type, thus streamlining the development process.

Another key advantage is the seamless integration with modern frameworks and technologies. IntelliJ supports a wide range of Java frameworks and provides out-of-the-box integration with tools like Maven, Gradle, and version control systems, which can be more intuitive than in Eclipse or Visual Studio Code. This makes it easier for developers to manage projects and dependencies, as well as to maintain a smooth workflow for continuous integration and deployment.

IntelliJ IDEA's user interface is designed to maximize developer productivity by offering a more intuitive and responsive experience. It provides a cleaner, more organized workspace than Eclipse, and many users find its interface to be more navigable and less cluttered. This focus on user experience reduces the learning curve for new users and enhances efficiency for seasoned developers.

The availability of the IntelliJ IDEA Community Edition is a significant advantage, offering a free, open-source version of the IDE. This makes it accessible to a wide range of developers, from students to professionals, without the need for an initial financial investment. The Community Edition includes many of the core features necessary for Java development, making it an excellent choice for those looking to develop pure Java applications or server-side code.

You can grab IDEA from here https://www.jetbrains.com/idea/

Since you are already on GCP, why not use their storage service for that? Another option would be to build your cluster with GCP computing instances and MinIO (https://min.io/) or to go with Backblaze (https://www.backblaze.com/). In both cases, you have an S3-compatible API; just with MinIO, you have more things available, like custom policies, hooks, and various integrations. And it is fast. Like very fast.

Lately, with all that AI buzz, langchain and all, I had to do a lot of Python work, where each service runs as a REST API end-point. Obviously, I wanted to go the “dynamic routing” way, as I did on Foxx Builder (https://github.com/skitsanos/foxx-builder) and other projects, so I needed Flask to handle my route handlers exactly the same way. I went with Gunicorn initially; you can even see it here: https://github.com/skitsanos/flask-dynamic-routes. But it all was fine until its multithreading backfired when I wanted to run it in containers. Azure libs that I used didn't like how it worked, and I needed a bunch of containers behind the load balancer. I had to migrate to Waitress, and my headaches were gone.

Waitress is single-threaded, which means it serves requests in a sequential manner, one after another. This makes it easy to reason about how your application handles concurrent requests.

Gunicorn, on the other hand, uses multiple worker processes (usually multiple threads within each process) to handle concurrent requests. While this can improve concurrency and performance, it can also introduce synchronization and thread safety complexities in your application code.

Waitress is designed to be a simple, production-ready WSGI (Web Server Gateway Interface) server that's easy to set up and use. It's a pure-Python server that doesn't require any additional configuration or management.

Gunicorn, while powerful and feature-rich, can be more complex to set up and configure, especially if you need to manage multiple worker processes. In my case, I didn’t need all that fancy stuff. Gunicorn sounded to me like a swiss-knife, when, in my case, I just needed a simple butter knife.

Waitress is a lightweight server with minimal overhead. It doesn't have as many features as Gunicorn, but it's often sufficient for smaller applications and can be a better choice when you want to keep your server footprint minimal.

Gunicorn is a more heavyweight server with more features and options. This can be advantageous for larger applications with high traffic, but it may be overkill for simpler projects.

Some of my things are offloaded to OpenResty directly, so Lua handles things even before it reaches the Python backend. My main criteria here were to have super-fast deployment, super simple configuration when running in a container, and the ability to handle a big load.