Ship Feature Case Study: One Pattern, Backend-Driven Config, and Localization - Part 6
Architecture & Decision Log·November 6, 2026·9 min read
All notes

Ship Feature Case Study: One Pattern, Backend-Driven Config, and Localization - Part 6

The Ship (Pelni) ticketing feature as a complete case study: how later travel modules reused its blueprint, how backend-driven configuration enables zero-release festive themes, and how modular ARB pipelines automate localization.

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.

FIG.
Ship Blueprint: The Foundation Reused Across Travel Features
Pattern Multiplication
Ship (Pelni) Feature as Reusable Architectural BlueprintPilot Laboratory

Ship was deliberately selected for its compact yet complete scope: route picking, remote berth API, SQLite caching, and decoupled BLoCs.

3-Layer Structure
BLoC Event/State
Central Dio Client
SQLite & Storage
Train & Bus (Rapid Adoption)
Direct Pattern Expansion
  • ✓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.
New feature delivery cycles accelerated by reusing foundational contracts
Flight Booking (High Complexity)
Battle-Tested Stability
  • ✓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.
Scales cleanly across independent feature engineering teams
Core Lesson:

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: ShipRepository abstracts 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: TrainRepositoryImpl combined live rail inventory from remote endpoints with local station searches stored in SQLite.
  • Predictable Use Cases: Actions like GetHarbourListUseCase, SearchShipSchedulesUseCase, and CalculateShipFareUseCase kept 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:

FIG.
Dynamic Theming: User Control vs Backend-Driven Event Themes
Dynamic Runtime Customization
User-Selected Theme (Light / Dark)Local & Persistent
  1. 01User Autonomy: Users freely choose Light, Dark, or System mode in application preferences.
  2. 02Local Storage: Saved in shared_preferences and hydrated instantaneously before initial frame.
  3. 03Nature: Deterministic client-side logic completely independent of internet connectivity.
Maintains user accessibility preferences locally
Backend-Driven Event OverridesDynamic Zero-Release Overrides
  1. 01Business Agility: Transforms UI accents during Eid, Christmas, New Year, or high-traffic sales.
  2. 02Remote Config: Fetched via config endpoint on launch; global BLoC updates banners and accent tints.
  3. 03Core Advantage: Visual updates deploy instantly without waiting for App Store / Play Store review cycles.
Requires local client fallback if network payload fails
Core Lesson:

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:

FIG.
Localization Pipeline: From Modular ARBs to Type-Safe Dart
Multilingual Architecture
01

Split ARB Files

Per-Feature ARBs

String keys are isolated into feature ARBs (intl_ship_en.arb, intl_auth_en.arb) to prevent bloat.

02

Automated Merge

CLI Script

Automated CLI script merges all feature ARBs into unified app_en.arb and app_id.arb files.

03

Code Generation

flutter gen-l10n

Flutter generates strongly-typed AppLocalizations classes with compile-time safety.

04

Live Runtime Locale

Language BLoC

LanguageBloc switches the active in-memory Locale dynamically without app restarts.

Core Lesson:

Splitting translations per feature and automating compilation eliminates massive git conflicts when teams translate dozens of strings simultaneously.

  1. Per-Feature Split ARB Files: Each feature maintains its own translation keys within its directory (e.g., features/ship/l10n/intl_ship_id.arb and features/auth/l10n/intl_auth_id.arb).
  2. Automated Merge CLI Script: A small, automated script scans all feature modules, merges their individual translation keys into unified root app_id.arb and app_en.arb files, and validates that no duplicate keys exist.
  3. Compile-Time Code Generation: The official flutter gen-l10n tool generates strongly typed AppLocalizations classes with complete compile-time type safety. Missing translation keys are caught immediately by the Dart compiler.
  4. Dynamic Runtime Locale Switching: A global LanguageBloc manages 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!