Project Overview
Formtastic is a service for creating forms and surveys used in business scenarios with high requirements for stability, speed, and interface flexibility. As the project grew, it became clear that further development required not only updating client technologies but also targeted optimization of the server side.
Auth Screen
Main Screen
Form Editor
Templates List
Template Editor
Migration from Django to Nuxt
Initially, Formtastic's frontend was implemented using Django templates. That allowed a quick start, but over time it began to limit product development. The interface grew more complex, changes required a backend developer, and the server spent too much time rendering HTML, which hurt scalability.
As a result, we architecturally separated the system. Django remained as the main backend and API, while the entire user interface was moved to a separate Nuxt frontend. This provided clear separation of concerns and allowed the interface to evolve independently from server logic.
After migration, UI development speed increased noticeably. The team started releasing new screens faster and improving user experience, while server load decreased as it stopped handling page rendering. Nuxt with SSR and SSG also brought clear gains in SEO and loading speed, which helped the marketing and public pages. This shape of migration — a template-rendered or single-page frontend moved onto Nuxt — is what our Nuxt development page covers.
In parallel, the server side began to evolve. In areas with increased load and strict performance requirements, part of the logic was extracted from Django and implemented in Go as separate services. This reduced latency, simplified horizontal scaling, and eliminated bottlenecks without completely reworking the backend.
Migration from Native Apps to Flutter
Formtastic's mobile clients were initially developed as two independent native applications — for iOS and Android. As the product grew, this approach became increasingly inefficient: development slowed down, features were released out of sync, and maintaining two codebases increased the total cost of ownership.
The transition to Flutter allowed us to consolidate mobile development into a single codebase. This significantly simplified maintenance and made new feature releases predictable. Updates began rolling out simultaneously on both platforms, and the interface and app behavior became completely consistent for all users.
From a business perspective, the effect was direct: development and maintenance costs decreased, time-to-market accelerated, and the team gained the ability to test hypotheses and develop the product faster without proportional cost increases. At the same time, Flutter allowed us to maintain high performance and quality user experience.
Concretely, the consolidation changed three numbers:
- Two codebases became one. Every feature, fix, and edge case is now written once instead of twice — the "we forgot to add this to Android" class of work disappeared entirely.
- Release drift went to zero. Before, an iOS release could precede its Android counterpart by a week or more; now one build ships to both stores at the same time.
- The annual platform-upgrade bill roughly halved. One Flutter upgrade cycle replaced two separate rounds of OS updates, SDK requirement bumps, and store-policy sweeps.
iOS Application
List of Documents
Form Editor
List of Forms
Documents Sync
Splashscreen
iPad Application
Auth Screen
Main Screen
Form Editor
Forms Search
New Document Dialog
For years, Formtastic shipped as two separate native apps — one for iOS, one for Android. Every feature had to be built twice, releases drifted out of sync between the platforms, and maintaining two codebases was quietly draining our roadmap.
Nerdy Production consolidated everything into a single Flutter codebase without disrupting the product our customers depend on. Now both apps ship the same features at the same time, the experience is identical on iPhone and Android, and our time to production has dropped dramatically. We maintain one codebase instead of two, and the team finally spends its energy on new features rather than keeping two apps in sync.
Voice-to-Text for Form Fields
Long free-text fields — inspection notes, incident reports, open-ended survey answers — are the slowest part of filling out a form on a phone. We added voice-to-text powered by Whisper, and implemented it differently on each client rather than forcing one architecture onto both.
On the web app, audio is recorded in the browser and sent to a new transcription endpoint on the existing Django backend — the smaller change, since Django already owns auth and storage for that request. On the Flutter apps, Whisper is bundled directly into the binary as a GGML build running through FFI, so transcription runs on-device: no upload, no round trip, and it keeps working with no signal at all — useful on a job site, exactly where a lot of Formtastic's forms get filled out.
The result is the same feature with two different trade-offs behind it. The web path stays simple because a backend was already there to extend. The mobile path trades a larger app bundle and on-device compute for dictation that works offline and never sends audio anywhere.
Summary
Formtastic's stack evolved deliberately, one bottleneck at a time. Moving the frontend from Django to Nuxt simplified web development and improved speed and SEO. Targeted use of Go on the server solved performance issues without radical platform changes. The transition from native mobile apps to Flutter reduced ownership costs and accelerated product development. As a result, the system became more stable, flexible, and better prepared for scaling.
FAQ
Consolidating Formtastic's two native apps into one codebase is exactly the kind of migration we handle in Flutter app development — and running the Nuxt web application alongside those apps, on the same Django and Go backend, is the kind of work our companion web app page describes.