Tiye Super App - Taxi, Jobs, and Marketplace in Flutter

Summary

• Delivery: end-to-end modules for Taxi (ride-hailing), Jobs (board + application wizard), and major Marketplace evolution (listings, seller tools, negotiation flows).
• How I unlocked scale: standardized a UI → Notifier → Service → Model flow with defensive parsing and reusable building blocks to keep shipping without breaking screens.
• Practical effect: the app gained real “product features” (not just screens), with higher-risk integrations (maps/location/uploads) and a more modular codebase by domain.

Over ~4 months, I owned and stabilized critical features in a Flutter super-app, integrating REST APIs and high-coupling modules (maps, ride state, file uploads) under constraints of limited quality infrastructure (tests/CI) and high delivery pressure.

Context

• Product and users: a multi-domain super-app (services + marketplace) with experiences for end users and role-specific areas (e.g., seller/driver).
• Why it mattered: Taxi and Marketplace are core retention/monetization loops-without them the app becomes a static showcase.
• Real constraints: low automated test coverage and limited delivery automation; changes needed to be incremental and production-safe.

Key Challenges

• Complex state and flows (Taxi): multiple modes (driver/passenger), map synchronization, permissions, and the ride lifecycle.
• Scaling without “spaghetti”: parallel features in the same app under time pressure, where rework is expensive.
• Inconsistent API payloads: large domains (Marketplace/Property) requiring robust, null-tolerant parsing to prevent crashes.

What I did

• Taxi & Ride-hailing: delivered the full flow (screens + state + integrations) with Google Maps and Geolocator, including notifier/service organization and reusable map components.
• Jobs (board + apply): built listings, details, and a multi-step application wizard (including file upload), designed for reuse and iterative expansion.
• Marketplace + Search + Seller tools: evolved listings with pagination/infinite scroll, improved search, and strengthened services/models to support seller dashboards and negotiation flows.
• Auth & Roles: reinforced authentication with secure local storage and role-based access (User/Seller/Driver), reducing friction around session/token handling.
• Media/News: integrated a media/news area with YouTube consumption.

Decisions & Trade-offs

• Provider/ChangeNotifier as the active state pattern: kept domain logic out of screens via Notifiers and dependency injection through Providers.
  Trade-off: without strong architecture/tests, it requires discipline to avoid logic drifting back into UI.
• Defensive model parsing (especially Marketplace/Property): prioritized tolerance to unstable payloads (nulls/missing fields).
  Trade-off: more “boring” mapper code, but fewer crashes and fewer urgent hotfixes.
• Integrations first, polish later: maps/location/uploads are risk multipliers; tackling them early reduced rework.
  Trade-off: some visual/UX refinement is deferred until core flows are stable.

Results

• Measured (engineering): 20 verified commits in the extracted slice (Feb–Jun 2025), with larger deliveries per commit.
• Concrete technical proxies:
  • Taxi ride lifecycle with Maps/Geolocation integration and role-dependent flows (driver/passenger).
  • Jobs module with listing/detail and a multi-step application flow (including upload).
  • Marketplace evolution with pagination, search improvements, and seller-oriented tools/flows.
  • Role-based auth using secure local storage, plus Media/News integration with YouTube.
• Operational impact: clearer separation by domain/feature (state + services + models), making it easier to keep multiple streams moving without stalling the app.

Note: sensitive product metrics (users/GMV/ride volume) were not accessible; technical evidence can be shared in a redacted “proof pack” upon request.

What I’d do differently

• Add real tests (unit + widget/integration) and define a minimum non-negotiable baseline per feature (notifier + service + parsing).
• Introduce CI/CD (build + lint + tests + checks) to reduce regressions and speed up delivery.
• Remove unused dependencies or plan a migration with a clear strategy (e.g., keep the current pattern or migrate state incrementally with tests).