class Developer {
  final String name = "Suhaili Faruq";
  final String role = "Mobile Engineer";
  final String location = "Jakarta, Indonesia";
  final int yearsOfExperience = 4;

  // Three stacks, all shipped to production. No favourites on the CV.
  final List<String> mobile = [
    "Flutter (Riverpod, BLoC)",
    "Kotlin (Native Android, Compose, KMP)",
    "React Native (Expo, New Architecture, Re.Pack)",
  ];

  // Side projects and one freelance deploy. Not a job title. Yet.
  final List<String> backend = [
    "Go (Fiber v3)",
    "Kotlin (Ktor)",
    "PostgreSQL",
    "Redis",
    "Docker, Nginx, VPS",
  ];

  final String focus =
      "Offline-first mobile apps with sync that survives a dead connection, "
      "backed by REST services I can build and deploy myself.";

  final int appsPublished = 7; // Play Store + App Store

  bool canOwnTheApiContract() => true; // both ends of it

  String mindset() => "Build clean. Build scalable. Keep learning.";
}

Four years of shipping mobile apps for mall loyalty programs, city government tax services, network operations tooling, batik e-commerce, and heavy equipment field inspection.

The through line is offline-first. Every app I care about had to keep working when the signal died, so I have written the same queued-sync problem three times over in Realm, Room, and SQLite. Flutter, Kotlin, and React Native are all in production under my name. Which one a project uses matters less to me than whether the data survives the tunnel.

I also write the service the app talks to. Go Fiber and Ktor, PostgreSQL, Redis, deployed to a VPS I keep alive myself. That is not a second career, it is the reason I stopped arguing with backend engineers about pagination.

Seven apps published to the Play Store and App Store, plus the enterprise app I build today. Ordered by recency, not by stack.

_{* COIP Mobile is an enterprise app distributed to United Tractors customers. The seven store-published apps are the rest.}

_{4 published apps, 2022 to 2024}

Four of the seven published apps are Flutter, across loyalty, maps, and network operations. NMSxPro ships an on-device SSH client so field technicians can run commands against network equipment straight from the phone. Riverpod 2 and Clean Architecture on ForYou and MyKekancan, BLoC on NMSxPro.

_{Native Android since 2021, plus Kotlin Multiplatform}

Where I started, and where I still go when a problem wants the platform directly. Naratik is native Kotlin with Hilt, Room, DataStore, and WorkManager background sync, plus a CNN authenticity checker from a paper I co-authored. KMP Todo shares domain models between an Android and iOS Compose client and a Ktor backend, so the whole thing is one language end to end.

_{2 published apps, plus the enterprise app I build today}

Hebat! for the Semarang city government and Kla Computer for Infokom, both Redux Toolkit. Currently building COIP Mobile at PT United Tractors Tbk: typed API layer generated from the backend OpenAPI spec with Kubb, so there is no hand-written client code and no schema drift. Conditional validation across 100+ fields in multi-tab checksheets. Around 100 unit and UI tests with Jest and RNTL.

The part I would actually put on a business card. Realm on COIP, Room plus WorkManager on Naratik, SQLite elsewhere. Jobs get created with no signal, photo evidence queues up, and everything reconciles when the technician walks back out of the basement. Nothing is lost in between, which sounds obvious until you have shipped it.

This is side-project and freelance work, not a job title I have held. What it buys me is the other end of the API contract. On COIP the typed client is generated straight from the OpenAPI spec, so the schema is the contract. On KMP Todo the client and the server share the same domain models in the same language. And the POS service is one I actually run, which is how I ended up learning Certbot, Nginx, and Docker Compose the hard way.

Hire me for mobile. The backend means you will not spend a sprint explaining why the endpoint is shaped that way.

Classification of Batik Authenticity Using Convolutional Neural Network Algorithm with Transfer Learning Method 2021 Sixth International Conference on Informatics and Computing (ICIC), IEEE, Nov 2021, pp. 1 to 6. DOI: 10.1109/ICIC54025.2021.9632937

The model from this paper became the authenticity checker inside the Naratik Android app.

Mobile:
  - Flutter: Riverpod, BLoC, Clean Architecture
  - Kotlin: Compose, KMP, Hilt
  - React Native: New Architecture, Re.Pack + Rspack, Module Federation

Architecture:
  - Clean Architecture
  - MVVM
  - Offline-first sync (Realm, Room, SQLite)

Backend:
  - Go Fiber v3
  - PostgreSQL, Redis
  - Docker, Nginx, CI/CD