Connecting the Dots: The Living Architectural Blueprint#
Across the first five parts of this series, we examined each layer of Holigo's architecture in isolation: the feature-by-feature migration strategy, the three-layer boundary contracts, BLoC event streams, modular dependency injection with get_it, navigation middleware with go_router, and a resilient network and dual-storage data layer.
In Part 6, the pieces converge. We examine how all these systems interlock in production through our pilot laboratory: the Ship (Pelni) ticketing module.
Beyond standard CRUD operations, a real-world travel booking module must navigate complex cross-cutting concerns: dynamic pricing models, offline local caching for frequent ports, external REST gateways, and dynamic marketing requirements. Here is how that blueprint formed the foundation for subsequent travel domains, how backend-driven remote configuration enables zero-release visual campaigns, and how modular ARB pipelines solved multilingual translation bottlenecks.
Ship was deliberately selected for its compact yet complete scope: route picking, remote berth API, SQLite caching, and decoupled BLoCs.
- ✓Zero Architecture Redesign: Developers immediately duplicate repository contracts, use cases, and injectors.
- ✓Focus on Business Logic: 100% bandwidth spent on rail wagons, seat maps, and transit station logic.
- ✓Complex Logic on Solid Ground: Multi-passenger tiers, dynamic baggage, and add-ons built on proven structures.
- ✓Zero Regressions: Heavy flight booking logic never destabilizes ship or train transactions.
The greatest return on the pilot feature is not the feature itself, but the battle-tested architecture blueprint it bequeaths to every future module.
Pattern Multiplication: Scaling from Ship to Rail, Bus, and Air#
When we chose the Ship module as our pilot project in Part 1, the goal was never just to ship ship tickets; the goal was to build an architectural mold that the entire Mobile Application Engineering team could replicate across the rest of the product catalog.
The anatomical blueprint established in the Ship feature proved immediately transferable:
- Repository Contract Separation:
ShipRepositoryabstracts away the underlying data sources. When the team began implementing Train and Bus ticketing, engineers did not have to debate directory conventions, layer boundaries, or data flow models. They duplicated the exact structure:TrainRepositoryImplcombined live rail inventory from remote endpoints with local station searches stored in SQLite. - Predictable Use Cases: Actions like
GetHarbourListUseCase,SearchShipSchedulesUseCase, andCalculateShipFareUseCasekept business logic decoupled from UI widgets. When Flight booking followed later with multi-tier passengers, dynamic luggage add-ons, and seat selection maps, developers focused 100% of their cognitive bandwidth on domain-specific calculations without reinventing foundational plumbing. - Immediate Team Velocity: Reusing a proven blueprint reduced development and verification time for subsequent travel modules by an estimated 35-40%. New team members onboarding into the project could inspect the Ship module and immediately understand how any other feature in the app functioned.
Backend-Driven Configuration: Festive Campaigns Without Store Submissions#
In mobile consumer apps, marketing and seasonal events move far faster than Apple App Store and Google Play Store review cycles. Waiting 48 hours for a binary release simply to display an Eid Mubarak or Christmas promotional banner on the booking dashboard is unacceptable for business growth.
To give our product and marketing teams real-time agility without compromising client stability, we implemented Backend-Driven Dynamic Configuration:
- 01User Autonomy: Users freely choose Light, Dark, or System mode in application preferences.
- 02Local Storage: Saved in shared_preferences and hydrated instantaneously before initial frame.
- 03Nature: Deterministic client-side logic completely independent of internet connectivity.
- 01Business Agility: Transforms UI accents during Eid, Christmas, New Year, or high-traffic sales.
- 02Remote Config: Fetched via config endpoint on launch; global BLoC updates banners and accent tints.
- 03Core Advantage: Visual updates deploy instantly without waiting for App Store / Play Store review cycles.
Backend-driven theming delivers agile marketing campaigns without app releases, but must be decoupled to respect user light/dark accessibility choices.
During app startup, a global configuration service fetches dynamic campaign tokens from our backend cluster. When a major cultural holiday or high-traffic flash sale arrives, the server payload dynamically overrides decorative UI attributes:
- Thematic Visual Accents: Accent colors, banner artwork, and festive greeting illustrations update on the fly across booking search forms and home cards.
- Preserved User Autonomy: Crucially, backend-driven festive theming is architecturally isolated from the user's Dark/Light mode preference. If a customer prefers Dark Mode for accessibility, the app remains in Dark Mode, gracefully blending the festive color accents into the dark palette without blinding the user with an unrequested white theme.
- Offline Fallback Guarantee: If a customer opens the app in an area with poor connectivity and the remote config endpoint fails, the app falls back instantly to local client defaults without showing an error banner or blocking user transactions.
Automated Multilingual Localization: The Modular ARB Pipeline#
Holigo serves a diverse user base, supporting Indonesian as our primary language alongside comprehensive English localization. We utilize Flutter's native localization tooling (flutter_localizations), which compiles JSON-like Application Resource Bundle (.arb) files into type-safe Dart classes.
However, in large engineering teams, managing localization inside a single monolithic app_en.arb file causes endless git merge collisions. If two developers add translation strings for different features on the same day, resolving merge conflicts in a 2,000-line JSON file is painful and error-prone.
To eliminate this friction, we engineered an Automated Modular ARB Pipeline:
Split ARB Files
Per-Feature ARBsString keys are isolated into feature ARBs (intl_ship_en.arb, intl_auth_en.arb) to prevent bloat.
Automated Merge
CLI ScriptAutomated CLI script merges all feature ARBs into unified app_en.arb and app_id.arb files.
Code Generation
flutter gen-l10nFlutter generates strongly-typed AppLocalizations classes with compile-time safety.
Live Runtime Locale
Language BLoCLanguageBloc switches the active in-memory Locale dynamically without app restarts.
Splitting translations per feature and automating compilation eliminates massive git conflicts when teams translate dozens of strings simultaneously.
- Per-Feature Split ARB Files: Each feature maintains its own translation keys within its directory (e.g.,
features/ship/l10n/intl_ship_id.arbandfeatures/auth/l10n/intl_auth_id.arb). - Automated Merge CLI Script: A small, automated script scans all feature modules, merges their individual translation keys into unified root
app_id.arbandapp_en.arbfiles, and validates that no duplicate keys exist. - Compile-Time Code Generation: The official
flutter gen-l10ntool generates strongly typedAppLocalizationsclasses with complete compile-time type safety. Missing translation keys are caught immediately by the Dart compiler. - Dynamic Runtime Locale Switching: A global
LanguageBlocmanages the active language state in memory, allowing users to toggle between English and Indonesian with immediate UI re-rendering and zero app restarts.
The Operational Price: Code Divergence and Pipeline Governance#
Operating a modular, backend-driven architecture yields immense flexibility, but it introduces real operational overhead that engineering leads must actively manage:
First, Debugging Code vs Server Divergence: When UI styling is influenced by backend configuration payloads, reproducing a visual defect requires understanding both the client codebase and the exact configuration payload the server sent at that specific hour. Maintaining reproducible staging environments with toggleable configuration flags became mandatory.
Second, The Two-Step Localization Ceremony: Splitting ARB files requires developers to run the merge-and-generate script whenever they add new UI copy. When engineers occasionally forgot to execute this step, local builds failed. We solved this by baking the localization merger into our git pre-commit hooks and CI pull-request validation pipelines.
Third, Managing In-Flight Skeletons: While our travel features adopted the Clean Architecture blueprint, several peripheral modules (such as legacy promotional webviews and secondary settings screens) remained in intermediate migration phases. Acknowledging partial technical debt transparently was critical to preventing team confusion.
What You Can Take from This Story#
If you are scaling a multi-feature Flutter codebase with cross-cutting configuration and localization requirements:
- Treat Your Pilot Feature as a Living Mold: Put extra architectural rigor into your first migrated module. The standards, naming conventions, and layer boundaries you establish there will be inherited by every subsequent feature.
- Decouple Marketing Themes from User Accessibility: When implementing backend-driven themes, ensure remote overrides never hijack user-controlled light/dark mode settings.
- Split Localization by Feature Domain: Prevent catastrophic git merge conflicts by keeping ARB files modular, and use automated scripts to compile them into unified assets.
- Automate Multi-Step Workflows in CI: Any required merge or code-generation step will eventually be forgotten if left manual. Embed generators into pre-commit hooks or automated pipeline guards.
Closing#
The Ship (Pelni) ticketing module proved that an upfront investment in disciplined Clean Architecture compounds into massive engineering dividends over time. By establishing clear layer boundaries, enabling zero-release festive campaigns, and automating localization pipelines, Holigo created a resilient platform capable of scaling to dozens of concurrent features.
In Part 7 (the final installment of this series), we turn our focus to the hard truths of Mobile Application Engineering: Quality and Release. We will examine our environment configurations, automated testing coverage, CI/CD deployment pipelines, release signing security, and the hard lessons I would apply differently if starting from scratch.
Thanks for reading :)
P.S. This series is written at the level of software design decisions and mobile system architecture, without disclosing proprietary code or internal company data. If you have questions about modular ARB workflows, backend-driven UI config, or travel booking blueprints, let's connect and discuss!