Hello and welcome! In this blog, we're sharing our candid experience with FlutterFlow, a platform that promises to streamline the process of building performant applications. As avid developers, we were eager to put FlutterFlow to the test and see if it lives up to the hype.

In the dynamic realm of mobile app development, FlutterFlow has emerged as a promising tool, offering a streamlined approach to building cross-platform applications with Flutter's powerful framework. While its user-friendly interface and drag-and-drop capabilities have garnered praise, it's crucial to delve into the less-explored territory—the potential shortcomings of FlutterFlow. Understanding these challenges is important for developers seeking a comprehensive perspective on the platform's capabilities and making informed decisions about its suitability for their projects. In this blog post, we'll share our experience in building production grade applications with FlutterFlow.

Before diving into our experience, let's get some background on the platform. FlutterFlow is a visual development platform built on top of Flutter, allowing developers to create mobile and web applications without delving deep into code. Apart from this, FlutterFlow also offers features like one click deployment to web applications, App store and play store, in-built functions to handle interactions with firebase projects.

FlutterFlow's marketing material is enticing, highlighting its drag-and-drop interface, real-time collaboration, and seamless integration with Flutter. The promise of rapid development without compromising performance was intriguing. We decided to choose this platform for our project which was in the education domain.

The following were our requirements for building the app:

Scalability and Performance

Design the platform to be scalable, accommodating a growing user base and increasing volumes of educational content without compromising the performance.

Cross-Platform compatible

Ensure that the platform is compatible with various devices and platforms, including web browsers, smartphones, and tablets, to provide flexibility in access.

Security and Compliance

Prioritize data security and compliance with privacy regulations, implementing encryption, secure authentication, and secure data storage practices.

Customization and Personalization

Provide customization options for administrators and educators to tailor the platform to their specific curriculum, teaching methods, and organizational needs.

APIs for Integration

Create APIs that enable integration with third-party educational tools, applications, and services, allowing for a more versatile and connected educational ecosystem.

Continuous Updates and Support

Provide regular updates to enhance features, address bugs, and ensure compatibility with evolving educational standards and technologies. Offer responsive customer support for users.

Payment and Subscription Management

Implement a secure payment gateway and subscription management system.

Learning Analytics

Integrate learning analytics tools to track and analyze user engagement, progress, and performance, providing valuable insights for educators and administrators.

Based on these requirements, we picked FlutterFlow to be the platform to build our app on.

Our Initial Impressions

Upon signing up, the intuitive interface and pre-built components were indeed impressive. We opened the documentation and started exploring the platform. In terms of UI, it was simple as anybody with a basic knowledge in the front end could understand the UI easily. In fact, we had a designer in our team and they were able to create pages and work on them within a week. UI was snappy as everything from clicking a button or creating a page to loading test sessions were responsive and quick. We didn’t have to go through pre-requisites like adding linters as it wasn’t required anymore. In terms of performance, it did seem to deliver what it promised. Building a page that would take a day (on a coding platform) only took us a couple of hours. By the end of the month, we had already created 40 pages along with their functionality. Based on the progress so far, it would have only taken us around a month (plus a week) to finish the rest of the app. 

However, that was not going to be the case. As we continued with the app development and the project size started growing, our experience on the platform would change.

The Critique Begins

At first, only one member was working on the application. As the complexity of the app grew, the app now contained up to 4 members working simultaneously. This is where we started to notice the first of many problems with FlutterFlow.

As we delved deeper into the development process, we encountered several pain points that cast doubt on FlutterFlow's performance claims. We have mentioned below the problems that we faced during the development of the apps on the platform:

Project Scale Limits

Despite its user-friendly interface, FlutterFlow imposes constraints on project size, challenging developers when undertaking large-scale applications. We had the following number of items in our project (approximately):

• 90 pages

• 150 custom functions, widgets and actions

• 60 custom components

• 30 images

• 100 API calls

• 100 App State data most of which were booleans and small objects

Although we are not sure what the exact limit is, In their latest update they mentioned that they have increased the project size limit by 25% (based on a community post).

Performance Hurdles

As project size started growing, the once seamless experience turned sluggish, demanding developers to endure prolonged delays of 5-10 seconds for even minor alterations. We did reach out to support regarding this and they suggested converting repeated widgets into components. However, doing this didn’t give us any noticeable performance improvements. Here’s a video showing the issue in action:

In the video, I'm trying to change the text from "My Dashboard" to "My Dashboard Page". As we can see, while trying to make the change, the cursor freezes for a few seconds during which nothing works. After a few seconds I'm able to continue making my changes.

Testing Turbulence

Testing sessions on FlutterFlow can become frustratingly slow or lead to crashes during evening hours, hindering the development process and impacting productivity. In some cases, the testing session would be stuck for so long that the session would end up expiring.

Extended Custom Code Compilation Times

The compilation of custom code becomes increasingly time-consuming as project size expands, posing a significant challenge to efficient development workflows.

Basic Widget Limitations

Despite having a range of widgets, FlutterFlow's offerings are often deemed basic. In our case, we found ourselves frequently creating custom widgets to meet specific design and functionality requirements.

Missing Basic Yet Important Features

Some fundamental features, such as setting animation values from variables, were absent, complicating the task of creating apps that contain dynamic animations.

Lack of prebuilt functionality for simple use cases

We had to write a lot of utility custom code/functions. For a no code platform, having to write a separate function even for simple tasks like comparing a string is quite cumbersome.

Code Modification Constraints

FlutterFlow's code download functionality is unidirectional, limiting developers from modifying downloaded code and uploading changes back into the platform, restricting flexibility in code management.

Unreliable Updates

FlutterFlow's bi-monthly updates, while intended to enhance the platform, occasionally lead to unintended consequences, breaking existing features and diverting valuable development time towards issue resolution. We often found ourselves opening the project one fine morning and seeing 10s of error messages caused by a new update.

Custom Code Editor Issues

The code editor in FlutterFlow, essential for checking issues and enabling autocomplete, is plagued by frequent and unpredictable interruptions, causing inconvenience for developers who rely on these features for efficient coding. A workaround we used to bypass this issue was to set up a local flutter project using vscode and write the code there (and test as well) and copy/paste it back to the FlutterFlow project once done.

Conclusion

In conclusion, our journey with FlutterFlow was a mix of excitement and skepticism. While it offers an accessible entry point for beginners, developers seeking robust customization and fine-tuned performance may face challenges.

While FlutterFlow exhibits promise for the future, the present moment may not be optimal for the development of applications on this platform. Noteworthy concerns, as seen above, have proven to be critical and have led us to suspend our current endeavors on this platform. We advocate for a prudent approach, allowing FlutterFlow the opportunity to mature before reevaluating its viability for our development needs in the future.