DEV Community: Qandil Tariq

Building a Real-Time Heart Rate Monitoring App with Kotlin + Google Cloud

Qandil Tariq — Wed, 17 Sep 2025 08:34:52 +0000

Health monitoring apps are everywhere, but most rely on external wearables.

What if you could track your heart rate directly on your phone and still sync results to the cloud for secure storage and analysis?

That’s exactly what I built as part of my MSc dissertation: a Heart Rate Monitoring App powered by Kotlin (Jetpack Compose) and a Python + Firestore backend.

🚩 Problem

Wearables are expensive and not always accessible.

So the question was:

Can we capture, process, and store heart rate data using only a smartphone, and still keep it reliable and secure?

✨ Features

📱 Real-time heart rate monitoring
🚨 Threshold alerts (notify if BPM is abnormal)
☁️ Cloud sync with Firestore
📊 Reports + trends visualization
🔐 User authentication with Firebase

🛠 Tech Stack

Frontend: Kotlin, Jetpack Compose, MVVM, Coroutines
Backend: Python Flask microservice
Cloud: Google Cloud Firestore
Auth: Firebase Authentication
CI/CD: GitHub Actions

⚙️ How It Works

User signs in (Firebase Auth).
The app captures heart rate (camera/sensor).
Readings are sent to Firestore.
A Python backend checks for alerts.
Users view reports + trends in the app.

💻 Sample Code

Kotlin — Saving Data to Firestore

val db = FirebaseFirestore.getInstance()
val heartRateData = hashMapOf(
    "userId" to userId,
    "heartRate" to bpm,
    "status" to status,
    "timestamp" to System.currentTimeMillis()
)

db.collection("HeartRateReading")
    .add(heartRateData)
    .addOnSuccessListener { Log.d("Firestore", "Saved!") }
    .addOnFailureListener { e -> Log.w("Firestore", "Error", e) }

Jetpack Compose — Displaying Trends

@Composable
fun HeartRateCard(avg: Int, max: Int, min: Int) {
    Column(
        modifier = Modifier.padding(16.dp)
    ) {
        Text("Avg: $avg BPM", fontWeight = FontWeight.Bold)
        Text("Max: $max BPM", color = Color.Red)
        Text("Min: $min BPM", color = Color.Blue)
    }
}

Python — Simple Alerting Service

from google.cloud import firestore

db = firestore.Client()

def check_alerts():
    docs = db.collection("HeartRateReading").stream()
    for doc in docs:
        data = doc.to_dict()
        if data["heartRate"] > 140:
            print(f"⚠️ High HR detected: {data['heartRate']} BPM for {data['userId']}")

📊 Screenshots

(Add your app UI and Firestore console screenshots here)

🎓 Lessons Learned

On-device vs cloud → trade-offs between privacy and performance
Importance of data security in healthcare apps
A clean UI/UX makes adoption easier
Cloud pipelines = real-time dashboards + analysis

🗺 Roadmap

🤖 Add ML models for anomaly detection
❤️ Expand to other vitals (SpO2, BP)
🍎 Build iOS client with Kotlin Multiplatform
🏥 Healthcare integration (e.g., NHS)

✅ Conclusion

This project showed me how AI + Mobile + Cloud can combine to deliver meaningful health insights.

👉 Code available here: HeartRateMobile

👉 Medium version (more detailed): Real-Time Health Monitoring on Android

Thanks for reading! Follow me for more posts about Android, AI, and cross-platform development 🚀

SmartCV: An AI-Powered Resume Analyzer with Jetpack Compose & Kotlin Multiplatform

Qandil Tariq — Sat, 13 Sep 2025 20:11:17 +0000

Job hunting is stressful — tailoring resumes to every job description is even worse.
So I built SmartCV, a mobile app that analyzes your resume and matches it against a job description — highlighting missing skills and suggesting improvements.

Tech Stack

Kotlin Multiplatform (KMP) → shared scoring + JD matching logic
Jetpack Compose → Android UI
PdfBox-Android → PDF parsing
Custom NLP-inspired Scoring Engine → resume quality + JD keyword match
GitHub Actions CI → build + test automation

Resume Analysis (Core Logic)

`fun analyzeResumeText(text: String): AnalysisResult {
val wordCount = text.split("\s+".toRegex()).size
val verbHits = ACTION_VERBS.count { text.contains(it, ignoreCase = true) }

val score = (verbHits * 10) + (if (wordCount in 400..900) 20 else 0)

return AnalysisResult(
    overallScore = score,
    signals = mapOf("Word Count" to wordCount, "Action Verbs" to verbHits),
    recommendations = buildRecommendations(wordCount, verbHits)
)

}`
This checks word count, action verbs, and generates recommendations like:

“Add more quantified bullets”

“Resume is too long — trim to 2 pages”

Matching with a Job Description

val resumeTokens = tokenize(resumeText).tokens.keys.map(::stem).toSet()
val jdTokens = tokenize(jdText).tokens.keys.map(::stem).toSet()

val present = jdTokens.intersect(resumeTokens)
val matchScore = (present.size.toDouble() / jdTokens.size * 100).roundToInt()

SmartCV computes a match score (%) and highlights missing keywords.
Example: if JD requires CI/CD and DataStore but your resume doesn’t mention them → flagged as gaps.

UI (Jetpack Compose)

Circular gauge for overall score
Progress bars for sub-scores (word count, verbs, metrics)
Chips for matched & missing skills
JD Match card with missing keyword suggestions

CI/CD

The repo ships with a GitHub Actions workflow:
Build & test on every PR
Assemble APK & upload as artifact

What’s Next

Export to PDF/CSV
Add ATS-style scoring (readability, formatting)
Extend KMP for iOS

Links

GitHub Repo → https://github.com/Qandil11/SmartCV-ResumeAnalyzer/tree/main
Demo Video → https://www.youtube.com/shorts/p_aBx-PjTWk

Would love your feedback!
What other features would make this useful for developers/job seekers?

Build an OCR Action pipeline with Kotlin: ML Kit (Android) + Ktor (server) + KMP roadmap

Qandil Tariq — Thu, 04 Sep 2025 13:29:26 +0000

LetterLens scans a paper letter, extracts text with ML Kit, classifies it, pulls deadlines, and returns what/when/next. Android UI is Jetpack Compose; the API is Ktor; and the core parsing is moving to Kotlin Multiplatform.

Demo: https://youtube.com/shorts/lvZbWHVL1h4

Repo: https://github.com/Qandil11/LetterLens

Architecture (minimal)

Android app: Compose + ML Kit OCR → sends extracted text

Ktor server: /explain returns { type, deadline, summary, actions, citations }

KMP (WIP): move parsing/classifier into :shared for reuse

Run it locally (quickstart)

// Start the server ./gradlew :server:run // healthcheck curl http://127.0.0.1:8080/health

Device networking options

Emulator: base URL = http://10.0.2.2:8080/

Physical device (USB):

adb reverse tcp:8080 tcp:8080

base URL = http://127.0.0.1:8080/

Physical device (Wi-Fi): use your Mac/PC LAN IP, e.g. http://192.168.x.y:8080/

 <application android:usesCleartextTraffic="true" />

Tiny Ktor module (sketch)

fun Application.module() { install(ContentNegotiation) { json() } routing { get("/health") { call.respond(mapOf("ok" to true)) } post("/explain") { val req = call.receive<ExplainReq>() val type = classify(req.text, req.hint) val deadline = extractDeadline(req.text, type) val (summary, actions, citations) = explainForType(type, req.text) call.respond(ExplainRes(type, deadline, summary, actions, citations)) } } }

Why KMP here?

The classification/date parsing is pure Kotlin → easy to share across Android/iOS/desktop.

Keeps the server thin; long-term we can ship fully on-device.

Roadmap

Swap rule-based classifier for a compact model

Expand letter libraries (NHS/Council/HMRC/DVLA/UKVI)

Accessibility polish and offline mode

Tags: #android #kotlin #kmp #jetpackcompose #ktor #mlkit #ocr #nlp #govtech

A Tiny KMP Connectivity Monitor (Android + iOS) — No Pods Required

Qandil Tariq — Tue, 02 Sep 2025 19:38:27 +0000

I open-sourced a minimal Kotlin Multiplatform connectivity monitor that exposes a single

StateFlow<ConnectivityStatus> from shared code.

Android: ConnectivityManager callbacks • iOS: SCNetworkReachability (no CocoaPods).

Repo: https://github.com/Qandil11/KMP-Connectivity-Monitor
Demo (YouTube): https://www.youtube.com/watch?v=ItkwVbaN8eo

Why I built this

Most apps need to react to connectivity. I wanted a production-style, zero-friction approach for Compose Multiplatform that keeps:

one API in commonMain
native implementations per platform
no CocoaPods requirement on iOS
easy to use from Compose

So I built KMP Connectivity Monitor.

The tiny API (commonMain)

// com.qandil.kmpconnectivity.connectivity.Connectivity.kt
package com.qandil.kmpconnectivity.connectivity

import kotlinx.coroutines.flow.StateFlow

enum class ConnectivityStatus { Online, Offline, Unavailable }

interface ConnectivityMonitor {
    val status: StateFlow<ConnectivityStatus>
    fun start()
    fun stop()
}

expect class ConnectivityMonitorFactory {
    fun create(): ConnectivityMonitor
}

Android actual — ConnectivityManager

Listen to ConnectivityManager callbacks and update a MutableStateFlow.

// shared/src/androidMain/.../connectivity/Connectivity.android.kt (excerpt)
private fun updateNow() {
    val caps = cm.getNetworkCapabilities(cm.activeNetwork)
    val online = caps?.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) == true &&
                 caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
    scope.launch {
        _status.value = if (online) ConnectivityStatus.Online else ConnectivityStatus.Offline
    }
}

override fun start() {
    updateNow()
    val req = NetworkRequest.Builder()
        .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
        .build()
    cm.registerNetworkCallback(req, callback)
}

Android manifest (app module):

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

Tip (for library lint): shared/src/androidMain/AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
</manifest>
iOS actual — SystemConfiguration (no Pods)

Use SCNetworkReachability to monitor the default route and update the flow.

// shared/src/iosMain/.../connectivity/Connectivity.ios.kt (excerpt)
@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)

private fun update(flags: SCNetworkReachabilityFlags) {
    val reachable = flags.toInt() and kSCNetworkReachabilityFlagsReachable.toInt() != 0
    val needsConn = flags.toInt() and kSCNetworkReachabilityFlagsConnectionRequired.toInt() != 0
    val online = reachable && !needsConn
    scope.launch {
        _status.value = if (online) ConnectivityStatus.Online else ConnectivityStatus.Offline
    }
}

Gradle link (SystemConfiguration):

// shared/build.gradle.kts
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget

kotlin {
    targets.withType<KotlinNativeTarget>().configureEach {
        binaries.all { linkerOpts("-framework", "SystemConfiguration") }
    }
}

Prefer NWPathMonitor? Switch the iOS impl to Network.framework and link that instead.

Using it in Compose

@Composable
fun Main(factory: ConnectivityMonitorFactory) {
    val monitor = remember(factory) { factory.create() }
    val status by monitor.status.collectAsState(ConnectivityStatus.Unavailable)

    LaunchedEffect(Unit) { monitor.start() }
    DisposableEffect(Unit) { onDispose { monitor.stop() } }

    // render your UI (e.g., a status card with Online / Offline / … Checking)
}

Platform entry points:


// Android
setContent { Main(factory = com.qandil.kmpconnectivity.connectivity.ConnectivityMonitorFactory(this)) }

// iOS
Main(factory = com.qandil.kmpconnectivity.connectivity.ConnectivityMonitorFactory())

How to run

Android: ./gradlew :androidApp:assembleDebug (or Run from Android Studio)

iOS: Run from Android Studio’s iOS config or your Xcode project (Simulator/Device)

Roadmap / help wanted

Flow.retryWhenOnline(monitor) helper

Expose network type (Wi-Fi/Cellular)

Tests with stubs

If this was useful, a ⭐ or PR would mean a lot:
Repo: https://github.com/Qandil11/KMP-Connectivity-Monitor

License

MIT (in the repo).