Forem: Saidur Rahman

Retain API in Jetpack Compose

Saidur Rahman — Fri, 26 Dec 2025 01:05:40 +0000

Mastering the Retain API in Jetpack Compose: Why & How It Matters

In modern Android development with Jetpack Compose, managing state effectively — especially across configuration changes — is crucial for building resilient and fluid UI experiences. That’s where the Retain API comes in.

In this article, we’ll explore:

🔹 What the Retain API is
🔹 Why it matters
🔹 How to use it with examples
🔹 Best practices
🔹 Helpful resources

What is the Retain API?

The Retain API in Jetpack Compose lets you preserve state across configuration changes like device rotation, process death, and navigation lifecycle events — without relying on manual save/restore logic.

Unlike typical remember or mutableStateOf, which hold state only during composition lifetime, the Retain API ties state to the lifecycle owner (e.g., ViewModel, NavBackStackEntry), ensuring it survives events like rotation.

Why Use the Retain API?

Here’s why the Retain API is a game-changer:

✅ Survives configuration changes (e.g., screen rotation)
✅ Works with process death restoration
✅ Integrates with ViewModels & Navigation
✅ More concise and Compose-friendly than onSaveInstanceState

It simplifies state persistence without boilerplate, so you can focus on building features.

Core Concepts

There are three key building blocks:

API	Purpose
`rememberRetained`	Persists state across composition & config changes
`RetainedSaveableStateRegistry`	Handles the save/restore lifecycle
`SavedStateHandle`	Works with ViewModels for state persistence

Example: Persist Form State with Retain API

Let’s say you have a simple form that you want to keep alive across rotations.

Without Retain API (Problem)

@Composable
fun ProfileForm() {
    var name by remember { mutableStateOf("") }
    var email by remember { mutableStateOf("") }

    Column {
        TextField(value = name, onValueChange = { name = it }, label = { Text("Name") })
        TextField(value = email, onValueChange = { email = it }, label = { Text("Email") })
    }
}

The moment the device rotates, the state is lost.

With Retain API

@Composable
fun ProfileFormRetained() {
    val retainedState = rememberRetained { mutableStateOf("") }
    val (name, setName) = retainedState

    val retainedEmail = rememberRetained { mutableStateOf("") }
    val (email, setEmail) = retainedEmail

    Column {
        TextField(value = name, onValueChange = setName, label = { Text("Name") })
        TextField(value = email, onValueChange = setEmail, label = { Text("Email") })
    }
}

Now the state survives rotation — and you write less code.

Using Retain API with ViewModel

If you’re using a ViewModel, you can store the retained state inside it:

class ProfileViewModel(
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    var name by savedStateHandle.getState("name") { "" }
    var email by savedStateHandle.getState("email") { "" }
}

In Compose:

@Composable
fun ProfileScreen(vm: ProfileViewModel = hiltViewModel()) {
    TextField(value = vm.name, onValueChange = { vm.name = it }, label = { Text("Name") })
    TextField(value = vm.email, onValueChange = { vm.email = it }, label = { Text("Email") })
}

This ensures even process death restoration, not just rotation persistence.

Best Practices

✨ Favor rememberRetained for UI state that must survive recomposition
✨ Use SavedStateHandle with ViewModel for process death and navigation state
✨ Scope retained state to where it logically belongs (e.g., ViewModel vs Composable)

Resource Links

Here are official resources to deepen your knowledge:

🔗 Android Dev — Jetpack Compose State & State Hoisting
https://developer.android.com/jetpack/compose/state

🔗 SavedStateHandle in ViewModel
https://developer.android.com/topic/libraries/architecture/viewmodel-savedstate

🔗 Jetpack Compose API Reference
https://developer.android.com/reference/kotlin/androidx/compose

Final Thoughts

The Retain API is one of those under-the-hood features that makes real-world Compose apps robust and maintainable. Whether you’re handling forms, navigation state, or UI flags, understanding how to retain state confidently will boost both developer productivity and user experience.

Happy Composing! 🎨📱

Automating Real-Life Workflows with n8n

Saidur Rahman — Sat, 20 Dec 2025 18:41:44 +0000

Scheduling, Chat, Smart Decisions & AI-Powered Automation

Automation has evolved far beyond simple “if this, then that” rules. Today, businesses need intelligent workflows that can understand language, summarize data, make decisions, and act autonomously.

This is where n8n, combined with AI models like Gemini, becomes a powerful solution.

In this blog, we’ll explore:

What n8n is and why it’s different
How AI fits into automation
Real-life automation examples using n8n AI
How you can build these workflows yourself using n8n.io/ai

Introduction & Motivation

The Problem Today

Most teams still struggle with:

Too many manual, repetitive tasks
Data scattered across multiple tools
Humans doing machine-friendly work
Traditional automation lacking intelligence and flexibility

The Solution

Automation + AI = Intelligent Workflows

By combining n8n’s workflow automation with AI reasoning, we can build systems that:

Understand natural language
Make smart decisions
Work 24/7 with minimal human intervention

This is where n8n + AI (Gemini, OpenAI, etc.) truly shines.

What is n8n?

n8n (pronounced n-eight-n) is an open-source, low-code workflow automation platform that allows you to visually connect apps, APIs, and services to automate complex processes.

Think of it as a more flexible, developer-friendly alternative to tools like Zapier or Make — with full control and self-hosting options.

n8n Overview

Open-source workflow automation tool
No-code / Low-code
Self-hosted or cloud-based
400+ built-in integrations

Key Capabilities

Scheduling (Cron jobs)
Webhooks
API calls
Conditional logic
Data transformation

How n8n Works (Key Features)

1. Visual Workflow Builder

A drag-and-drop interface lets you connect nodes like puzzle pieces, making automation easy to understand and maintain.

2. Node-Based System

Each node performs a single task:

Fetch data
Call an API
Send an email
Run AI prompts
Transform JSON data

3. Open-Source & Self-Hostable

You own your data and infrastructure. No vendor lock-in.

4. Low-Code / No-Code Friendly

Non-developers can build workflows visually, while developers can inject custom JavaScript for advanced logic.

5. Powerful Data Handling

n8n works like an ETL tool, moving and transforming structured JSON data between systems.

Why AI + Automation?

Traditional Automation

“If this → then that”

AI-Powered Automation

Understand → Decide → Act

AI Enables:

Natural language understanding
Context-aware decision-making
Text summarization
Smart classification
Conversational workflows

This is exactly why n8n introduced native AI workflows.

n8n AI: Built-In Intelligence

n8n provides dedicated AI features documented at:
👉 https://n8n.io/ai/

What n8n AI Offers

AI Agent nodes
Prompt templates
Structured JSON outputs
Memory & context handling
Easy integration with LLMs (Gemini, OpenAI, etc.)

You can build AI-powered workflows without writing complex backend code.

🎥 YouTube Learning Resources
n8n’s official YouTube channel provides step-by-step tutorials covering:

AI agents
Chatbots
Email automation
Scheduling & monitoring workflows

(Perfect for beginners and advanced users.)

Architecture: n8n + Gemini AI

High-Level Flow

Trigger (Webhook / Schedule)
        ↓
n8n Workflow
        ↓
Gemini API (Prompt + Data)
        ↓
AI Response
        ↓
Decision / Action

Integration Method

HTTP Request or AI Agent node
Secure API key authentication
Prompt engineering inside n8n

Real-Life Automation Examples

Example 1: AI Chatbot Integration (Customer Support)

Scenario

A business receives hundreds of repeated customer questions through:

Website chat
WhatsApp
Slack

Problem

Support team overloaded
Delayed responses
Poor customer experience

Solution: AI Chatbot with n8n

Workflow Steps

User sends a message
Webhook triggers n8n
Message is sent to Gemini via AI node
Gemini understands intent and generates a reply
n8n sends the response back
Optional escalation to human support

Example Prompt

You are a customer support assistant.
Answer politely and concisely.
User question: {{$json.message}}

Result

✅ 24/7 AI support
✅ Reduced workload
✅ Faster responses

📸 Screenshot suggestion:

Webhook trigger
AI Agent node
Response node

Example 2: Scheduled AI Reports (Daily Business Summary)

Scenario

Managers need daily insights from sales and operational data.

Problem

Manual analysis is time-consuming
Reports are inconsistent
Important trends are missed

Solution: Scheduled AI Reporting

Workflow

Cron trigger (Every day at 9 AM)
Fetch data from DB / Google Sheets
Send data to Gemini
Gemini summarizes trends and anomalies
n8n emails the report or posts to Slack

Example Prompt

Analyze the following sales data.
Summarize key insights and risks.
Data: {{$json}}

Output

Human-like executive summary
Actionable insights
Zero manual effort

📸 Screenshot suggestion:

Cron node
Data fetch node
AI summarization node
Email / Slack node

Example 3: Smart Workflow Decisions (AI Task Routing)

Scenario

Incoming support or job requests need intelligent routing.

Problem

Static rules don’t scale
Edge cases are hard to manage

Solution: AI-Based Decision Engine

Workflow

Receive incoming request
Gemini classifies urgency and intent
n8n assigns:

Team
Priority
SLA

Example AI Output

{
  "priority": "High",
  "team": "Support Level 2",
  "sla": "2 hours"
}

Result

Smarter routing
Faster resolution
Reduced manual triage

📸 Screenshot suggestion:

Input webhook
AI classification node
Conditional routing

Security, Cost & Best Practices

Security

Store API keys securely
Avoid sending sensitive personal data
Use environment variables

Cost Optimization

Limit token usage
Use summaries instead of raw data
Cache AI responses when possible

Best Practices

Write clear prompts
Use structured JSON outputs
Add fallback logic
Enable logging and monitoring

Future Possibilities with n8n AI

AI agents coordinating multiple workflows
Voice-based automation
Automatic approvals
AI-driven business operations
Intelligent monitoring & alerting

Final Thoughts

n8n handles execution.
AI models like Gemini provide intelligence.

Together, they enable:

Smarter automation
Faster decision-making
Scalable, future-ready workflows

Start small, automate one process, then scale intelligently.

Useful Links

n8n AI Docs: https://n8n.io/ai/
n8n Official Website: https://n8n.io
n8n YouTube Tutorials (Search: “n8n AI workflows”)

KMP vs CMP: Kotlin Multiplatform vs Compose Multiplatform – A Complete Guide

Saidur Rahman — Mon, 15 Dec 2025 14:41:04 +0000

Introduction

As mobile and cross-platform development continues to evolve, Kotlin Multiplatform (KMP) and Compose Multiplatform (CMP) have emerged as two powerful technologies backed by JetBrains. While they are often mentioned together, they serve different purposes and solve different problems. This blog post explains what KMP and CMP are, how they differ, where they overlap, and when to use each.

What is Kotlin Multiplatform (KMP)?

Kotlin Multiplatform (KMP) is a technology that allows developers to share business logic across multiple platforms while still writing platform-specific UI.

Supported Platforms

Android (JVM)
iOS (Native)
Web (JavaScript)
Desktop (JVM)
Backend (JVM)

What You Share in KMP

Business logic
Data models
Networking layer
Validation logic
Domain layer

What You Don’t Share

UI code (by default)
Platform-specific APIs

How KMP Works

KMP lets you write common code in a shared module (commonMain) and platform-specific implementations in:

androidMain
iosMain
jsMain
desktopMain

The shared code is compiled to native binaries or bytecode depending on the platform.

Key Benefits of KMP

Maximum code reuse without sacrificing native UI
Native performance
Full access to platform APIs
Easier gradual adoption in existing apps

KMP Example (Shared Logic)

class UserRepository {
    fun getUserName(): String {
        return "Saidur Rahman"
    }
}

Used from Android (Kotlin) and iOS (Swift) seamlessly.

What is Compose Multiplatform (CMP)?

Compose Multiplatform (CMP) is a UI framework that allows developers to share UI code across multiple platforms using Jetpack Compose.

CMP focuses on how the app looks, not how business logic is structured.

Supported Platforms

Android
Desktop (Windows, macOS, Linux)
Web (Experimental)
iOS (Beta)

What You Share in CMP

UI components
Screens
Navigation logic
UI state management

How CMP Works

CMP uses the Compose declarative UI paradigm, where UI is written once and rendered across platforms.

CMP Example (Shared UI)

@Composable
fun Greeting(name: String) {
    Text("Hello, $name")
}

The same UI code can run on Android, Desktop, and iOS.

Key Differences: KMP vs CMP

Feature	Kotlin Multiplatform (KMP)	Compose Multiplatform (CMP)
Primary Purpose	Share business logic	Share UI code
Focus	Data, domain, networking	UI and presentation
UI Sharing	❌ Not included	✅ Yes
Platform Access	Full native access	Limited in some cases
Maturity	Stable	Android stable, others evolving
Ideal For	Native apps with shared logic	Apps with shared UI

KMP + CMP: Better Together

KMP and CMP are not competitors—they are complementary.

Ideal Architecture

KMP → Shared business logic
CMP → Shared UI layer

This approach enables:

Maximum code sharing
Faster development
Consistent UI across platforms

Example Architecture

┌──────────────────────┐
│   Compose UI (CMP)   │
└──────────────────────┘
            ↓
┌──────────────────────┐
│ Shared Logic (KMP)   │
└──────────────────────┘
            ↓
┌──────────┬──────────┐
│ Android  │   iOS    │
└──────────┴──────────┘

When to Use KMP

Choose Kotlin Multiplatform if:

You already have native Android and iOS apps
You want to share business logic only
You need full control over native UI
You want gradual migration

Common Use Cases

Banking apps
Enterprise apps
Apps with complex business rules

When to Use CMP

Choose Compose Multiplatform if:

You want to build UI once and reuse it
Your app UI is mostly similar across platforms
You are starting a new project

Common Use Cases

Internal tools
MVPs and startups
Desktop-first applications

Performance Considerations

KMP delivers native performance because it compiles directly to platform-specific binaries
CMP performance is excellent on Android and Desktop, with iOS and Web still improving

Learning Curve

KMP is easier for existing Android developers
CMP requires understanding Compose and declarative UI principles

Final Verdict

Scenario	Recommended Choice
Share business logic only	KMP
Share UI only	CMP
Full cross-platform app	KMP + CMP

Conclusion

Kotlin Multiplatform and Compose Multiplatform are shaping the future of cross-platform development. KMP excels at logic sharing, while CMP shines in UI sharing. Together, they provide a powerful, modern alternative to traditional cross-platform frameworks.

If you are an Android developer aiming to become a full-stack mobile engineer, learning KMP first and then CMP is a smart, future-proof strategy.

ChatGPT Prompt Engineering for Developers

Saidur Rahman — Sat, 13 Dec 2025 17:20:00 +0000

Excited to share that I’ve successfully completed the “ChatGPT Prompt Engineering for Developers” course by DeepLearning.AI! 🎉

This course strengthened my understanding of how to design effective prompts, optimize AI responses, and build reliable AI-powered applications.

Looking forward to applying these skills in real-world projects! 🚀

https://learn.deeplearning.ai/accomplishments/9dbb2e19-bc98-4c87-8856-c161e9ef1af6

Swift Is Coming to Android

Saidur Rahman — Sun, 19 Oct 2025 15:57:08 +0000

Exciting News: Swift Is Coming to Android – Officially! 🚨

📅 June 25, 2025 marked a game-changing moment for mobile development:
Swift.org has launched a dedicated Swift Android Workgroup — aiming to bring first-class Android support to the Swift programming language! 🧑‍💻💥

What Does This Mean?

Apple’s open-source language, Swift, is no longer just for iOS, macOS, and watchOS — it's officially expanding to Android, with real infrastructure and momentum behind it.
This is not an experimental side project — Swift’s Android journey is being actively developed and supported by the community, with strategic goals in mind.

What’s Included So Far?

✅ Official Swift SDK for Android
✅ Continuous Integration (CI) builds for Linux & Windows targeting Android
✅ Native Swift toolchain support for Gradle, JNI interop, and Android Studio compatibility
✅ Swift applications running directly on Android devices
✅ Early integration with Jetpack Compose via the Skip framework
✅ Improved developer tooling for cross-platform workflows

Why This Matters

For years, cross-platform development meant Flutter, React Native, or Kotlin Multiplatform (KMP) — each with strengths but also tradeoffs.
But now, with Swift joining the Android ecosystem natively, a new class of true cross-platform development is emerging:
Build iOS & Android apps in pure Swift
Share UI and business logic with Skip + Jetpack Compose
Eliminate JavaScript bridges or Dart runtimes
Tap into native performance, UI components, and tooling

What’s Next?

📦 Developers can already start experimenting with the Swift Android SDK
🧪 Try writing pure Swift Android apps
🛠️ Expect more ecosystem support, tutorials, and tooling improvements in the coming months
🤝 Ideal for Swift devs entering Android, or Android devs exploring multiplatform

The Future of Mobile is Native & Multiplatform

This shift means Swift is no longer confined to Apple platforms. The future is looking truly native across both ecosystems, and we're entering a world where Swift talks to Android seamlessly.
✨ It’s the beginning of a new era — where native iOS and Android development aren’t siloed but connected through Swift.

Model Context Protocol (MCP)

Saidur Rahman — Sun, 19 Oct 2025 03:53:22 +0000

Artificial Intelligence (AI) is currently one of the most discussed topics in the tech world. As a Mobile Developer (Android & iOS), I’ve been exploring how AI can be effectively used in mobile applications.

Recently, I started working with Model Context Protocol (MCP). With MCP, app data can easily be connected to LLMs like Claude or Cursor and utilized as searchable queries.

Although SDKs for Kotlin, Java, TypeScript, and Python are available for MCP, resources in Kotlin are quite limited. This makes the learning process a bit challenging but also creates a great opportunity for Kotlin developers.
Currently, I’m working on building an MCP server in Kotlin with JetBrains IDE, which in the future can be directly integrated with LLMs like Claude or Cursor. I hope to share a working demo code soon.

Here’s a visual of how an MCP server actually works 👇

🔗 If you are working on or interested in AI + Mobile Development, feel free to connect. By sharing experiences and ideas, we can make this journey even more enriching.

কৃত্রিম বুদ্ধিমত্তা (AI) বর্তমানে প্রযুক্তি জগতের অন্যতম আলোচিত বিষয়। একজন Developer (Android & iOS) হিসেবে আমি খুঁজে দেখছি কীভাবে মোবাইল অ্যাপ্লিকেশনে AI-কে কার্যকরভাবে ব্যবহার করা যায়।

সম্প্রতি আমি Model Context Protocol (MCP) নিয়ে কাজ শুরু করেছি। MCP-এর মাধ্যমে অ্যাপের ডেটা সহজেই Claude বা Cursor-এর মতো LLM-এর সাথে সংযুক্ত করে সার্চেবল কুয়েরি আকারে ব্যবহার করা যায়।

যদিও MCP-এর জন্য Kotlin, Java, TypeScript, Python সহ একাধিক ভাষায় SDK আছে, তবে Kotlin-এ রিসোর্স কিছুটা কম। ফলে শেখার প্রক্রিয়াটি কিছুটা চ্যালেঞ্জিং হলেও এটি Kotlin ডেভেলপারদের জন্য একটি বড় সুযোগ তৈরি করছে।

বর্তমানে আমি JetBrains IDE এর সাথে Kotlin-এ MCP server তৈরির কাজ করছি, যা Claude বা Cursor এর মতো LLM-এর সাথে সরাসরি ব্যবহার করা যাবে। আশা করছি শিগগিরই একটি কার্যকরী উদাহরণ (demo code) শেয়ার করতে পারব।
নিচে একটি ভিজ্যুয়াল দেওয়া হলো, MCP server আসলে কীভাবে কাজ করে

https://lnkd.in/gpDBJPwM

যদি আপনি AI + Mobile Development নিয়ে কাজ করেন বা আগ্রহী হন, চাইলে কানেক্ট হতে পারেন। অভিজ্ঞতা ও ধারণা বিনিময়ের মাধ্যমে এই যাত্রাকে আরও সমৃদ্ধ করা সম্ভব।