DEV Community: Cahyanudien Aziz Saputra

I Write Code All Day. Then I Write Poetry at Night. Here’s Why

Cahyanudien Aziz Saputra — Thu, 14 May 2026 07:14:46 +0000

I never planned to be a poet.

I planned to be a developer. And that's what happened — I build apps, write code, ship products. A lot of people use what I make. Most of them don't know my name.

But there are things code cannot fix.

Code is a precise language. Poetry is an honest one.

When I write a function, I know what it wants. There's an input, an output, logic in between. Everything is testable. If something's wrong, there's an error message.

Life doesn't work like that.

There are days that feel heavy without reason. Losses that never got named. Questions that are more comfortable left unanswered than resolved.

Code can't hold that. Poetry can.

Not because poetry has answers — quite the opposite. Poetry is the space where questions are allowed to stay questions. Where "I don't know" isn't an error, it's part of the process.

Night is the only honest time

During the day, I'm busy. Features to ship, bugs to fix, notifications that don't stop. All of it is real and needs to get done.

But the night — the night is mine.

That's where I started writing. Not with a specific goal. Not with a word count target. Just sitting down and letting something come out.

Some nights only a few lines came. Some nights nothing at all. But there were nights when I wrote something and felt — this. This is the thing I couldn't say any other way.

Two languages, one person

People often ask: how can you be a developer and write poetry?

The better question might be: how could you not?

Both are ways of making something from nothing. Both start from a question that doesn't have an answer yet. Both require the patience to sit in uncertainty until something becomes clear.

The difference — code is done when it runs. Poetry is done when it feels right.

Then it became a book

After writing long enough in the nights, I had a collection of words that didn't know where to go.

I arranged them. Read them again. Removed what wasn't honest, kept what felt true.

That became Stillness That Walks — my first poetry book. Twenty-four poems in three parts: Roots, Growth, Sky. A journey that doesn't offer conclusions, only company.

I didn't write it as someone who has arrived. I wrote it as someone still walking.

Maybe you've been at that point too.

If you're curious, the book is here: cahyanudien.site/stillness-that-walks

And if you're also a developer quietly carrying something — maybe it's time to let it out.

Cahyanudien Aziz Saputra is the founder of FlagoDNA, a self-taught app developer. He lives in quiet — writing code, assembling logic, arranging meaning. Many people use what he builds. No one knows how many nights he spent in silence. This book is one of the ways he finally spoke.

JDU — Jira Desktop Unofficial: A Minimal Jira Desktop Wrapper Built with Tauri | Cahyanudien Blogs

Cahyanudien Aziz Saputra — Thu, 14 May 2026 02:56:35 +0000

Stop letting browser tabs steal your focus.

If you use Jira every day, you already know the feeling. You open a new tab to check a ticket. Five minutes later you're reading an article, skimming a notification, or stuck in a rabbit hole you didn't plan for. The work you opened Jira for? Still waiting.

This is the problem JDU — Jira Desktop Unofficial was built to solve.

JDU (short for Jira Desktop Unofficial) is a minimal, focused desktop wrapper for Jira — built with Tauri and Rust. It gives Jira its own dedicated window, completely separate from your browser. No tabs. No distractions. Just your work.

💡 JDU = Jira Desktop Unofficial (JDU) — A Minimal Jira Desktop Wrapper Built with Tauri.

That's the full name. You'll see it everywhere: in the app, in the releases, and in the community.

🔗 Quick Links


📥 Download	github.com/cas8398/jira-desktop-unofficial/releases
⭐ GitHub	github.com/cas8398/jira-desktop-unofficial
🌐 Project Page	cas8398.github.io/jira-desktop-unofficial
📖 Medium	Read the original story

🖥️ What Is JDU?

JDU — Jira Desktop Unofficial is a desktop application that wraps your Jira instance in a clean, native window. It doesn't add new features to Jira itself — it changes how you access it.

Instead of opening Jira inside a browser tab surrounded by noise, JDU gives it its own space. You launch it like you launch Slack or VS Code. It opens directly into Jira. You work. You close it. That's it.

Under the hood, JDU uses Tauri — a modern framework that combines a Rust backend with your operating system's native webview. This means no Chromium bundled inside, no Node.js bloat, and no 300MB memory drain before you've even logged in.

It supports any Jira instance: Jira Cloud, Jira Server, and Jira Data Center. On first launch, you paste in your URL. JDU remembers it. Every launch after that goes straight to your board.

✨ Features

🖥️ Dedicated Window

Jira gets its own window — completely isolated from your browser. Alt-Tab to JDU the same way you'd switch to Slack or your terminal. Your other tabs stay clean.

⚡ Ultra-Lightweight

JDU uses ~80MB of RAM at runtime and downloads at under 8MB. It starts in under 2 seconds. Compare that to a typical Electron app at 350MB RAM and 120MB to download.

🔒 Privacy-First

Zero tracking. Zero telemetry. Zero data collection of any kind. Your Jira credentials are handled entirely by Jira's own login system — exactly as in a browser. JDU has no backend servers and sends nothing anywhere. The full source code is on GitHub.

🌐 Works With Any Jira

✅ Jira Cloud (*.atlassian.net)
✅ Jira Server (self-hosted)
✅ Jira Data Center

🧠 Smart Memory

JDU remembers your Jira URL and window size/position across sessions. Open the app, get straight to your board — no setup, no re-entering URLs.

🎨 Custom Backgrounds & Overlay

Starting in v0.1.3, you can personalize the JDU window with 5 curated background images and fine-tune overlay opacity (0–100%) to match your taste.

🔄 Dynamic Window Titles

The window title updates as you navigate between Jira pages — so if you use your taskbar or window switcher, you always know exactly where you are.

📱 Cross-Platform

JDU runs natively on Windows, macOS, and Linux. Same experience, same performance, everywhere.

🧩 Why Not Electron? (And Why This Matters for Jira Users)

This is the question most developers ask first — and it's a fair one. Almost every "desktop wrapper" app you've used was built with Electron. There's a reason JDU is different.

The Electron problem

Electron works by bundling an entire copy of Chromium — Google Chrome's rendering engine — into every app. Every. Single. App. That means:

Your Jira wrapper carries ~120MB of download just to boot
It consumes 300–500MB of RAM before you've opened a single ticket
Startup takes 5–8 seconds
Background CPU usage stays elevated even when idle

If you have multiple Electron apps running (Slack, VS Code, Notion, etc.), the cumulative memory cost becomes significant. Adding a Jira Electron wrapper on top of that is just more tax.

The Tauri approach

Tauri doesn't bundle Chromium. Instead, it uses the webview already built into your OS:

WebView2 on Windows (powered by Edge)
WebKit on macOS and Linux

The rendering quality is identical. The resource cost is a fraction. And because the backend is written in Rust — a memory-safe, compiled systems language — the app is secure and fast by design.

For Jira users specifically, this matters because JDU is likely running all day. A tool you keep open for 8 hours should not be quietly draining your battery and RAM for 8 hours.

📈 Performance at a Glance

Metric	JDU	Typical Electron App	Browser Tab
Memory Usage	~80 MB	~350 MB	~150 MB
Startup Time	< 2 seconds	5–8 seconds	Instant
Download Size	~8 MB	~120 MB	N/A
Background CPU	Minimal	Moderate	High (with other tabs)
Tracking / Telemetry	None	Varies	Browser-level

🚀 Getting Started in 60 Seconds

Step 1 — Download

Head to the GitHub releases page and grab the installer for your OS.

Step 2 — Install

🪟 Windows

Run the .msi or .exe installer. JDU requires Microsoft Edge WebView2 — most Windows 10/11 machines already have it. If not, download it here.

🍎 macOS

Open the .dmg file and drag JDU to your Applications folder.

🐧 Linux

Available as .AppImage, .deb, or .rpm. Download the format that fits your distro.

🔧 Build from Source

git clone https://github.com/cas8398/jira-desktop-unofficial
cd jira-desktop-unofficial
pnpm install
pnpm tauri build

Requires Rust, Node.js, and the Tauri prerequisites for your platform.

Step 3 — Launch

Open JDU, paste your Jira instance URL (e.g. https://yourcompany.atlassian.net), press Enter — and you're in. JDU remembers the URL from now on.

🔍 Deep Dive: JDU for Power Jira Users

If you live in Jira — sprints, backlogs, board views, Confluence-linked tickets, JQL filters — here's what JDU specifically does and doesn't change for you.

What stays the same

Everything Jira does in the browser works identically in JDU. JDU is a wrapper — it renders the real Jira web interface inside a native window. Your keyboard shortcuts, your saved filters, your board layouts, your integrations — all untouched.

What gets better

Focus: No browser tabs means no accidental navigation away from Jira mid-task.
Switching: JDU appears in your taskbar/dock like any native app. Alt-Tab to it in one move.
Window memory: JDU remembers where you left the window and how big it was. Reopen it, it's right where you left it.
Background behavior: JDU uses minimal CPU when it's not in focus, unlike a browser tab that may keep running scripts actively.
Custom aesthetic: With v0.1.3, you can now set a background image and control overlay opacity — making your Jira window feel more personal.

What's still on the roadmap

Desktop push notifications for Jira updates
Keyboard shortcut layer for quick actions
Dark mode and custom theme support
Multi-account / multi-instance support
Offline connection status indicators

🔖 What's New in v0.1.3

The latest release brings meaningful visual and UX improvements:

Custom Backgrounds — 5 curated Pexels images to personalize your workspace
Dynamic Window Titles — The title bar updates as you move between Jira pages
Modern UI Redesign — Cleaner interface throughout the app
Better URL Validation — Handles trailing slashes and edge-case URLs correctly
Smarter Domain Detection — More reliable Cloud vs. Server instance detection
Overlay Opacity Control — Slider from 0 to 100% to control background darkness
Bug Fix — URL validation issue (#2) resolved

Special thanks to @tsenzuk, @bupemko, @pdkrg, and @mitrapartha for reporting and helping fix the URL validation bug.

🎯 Who Should Use JDU?

JDU is for you if:

You're a developer, tech lead, or engineering manager who navigates Jira daily
You're a project manager or Scrum Master who lives on the board and backlog views
You care about lightweight, efficient tooling and hate RAM-hungry Electron apps
You want a distraction-free workflow and browser tab chaos is real for you
You value open-source, auditable software with no hidden data collection

JDU is probably not for you if you primarily use Jira occasionally and don't mind the browser tab experience.

🤝 Contributing & Community

JDU is fully open source under the MIT license and welcomes contributions of all kinds.

Bug reports → GitHub Issues — include your OS, app version, and steps to reproduce
Feature requests → GitHub Discussions
Pull requests → Fork the repo, make your change, open a PR
Give it a star → Helps the project get discovered by others who'd benefit from it

📥 Download JDU Now

Free. Open source. Under 8MB. No Electron. No bloat.

➡️ Download JDU — Jira Desktop Unofficial

⭐ Star on GitHub

🌐 Visit the Project Page

🛑 Disclaimer: JDU is an independent, community-built project and is not affiliated with or endorsed by Atlassian. Jira is a registered trademark of Atlassian Corporation Plc. JDU is a desktop wrapper around the official Jira web interface.

Built with ❤️ by cas8398 using Tauri — MIT License

Aku Nulis Kode Seharian. Lalu Nulis Puisi di Malam Hari. Ini Kenapa

Cahyanudien Aziz Saputra — Wed, 13 May 2026 02:59:01 +0000

Aku tidak pernah merencanakan jadi penyair.

Aku merencanakan jadi developer. Dan itu yang terjadi — aku membangun aplikasi, menulis kode, merilis produk. Banyak orang memakai apa yang aku buat. Sebagian besar tidak tahu namaku.

Tapi ada sesuatu yang tidak bisa diselesaikan dengan kode.

Kode adalah bahasa yang jelas. Puisi adalah bahasa yang jujur.

Ketika aku menulis fungsi, aku tahu apa yang diinginkan. Ada input, ada output, ada logika di antaranya. Semuanya bisa diuji. Kalau salah, ada pesan error.

Hidup tidak bekerja seperti itu.

Ada hari-hari yang terasa panjang tanpa alasan. Ada kehilangan yang tidak sempat diberi nama. Ada pertanyaan yang lebih nyaman dibiarkan menggantung daripada dijawab.

Kode tidak bisa menampung itu. Puisi bisa.

Bukan karena puisi punya jawaban — justru sebaliknya. Puisi adalah ruang di mana pertanyaan boleh tetap menjadi pertanyaan. Di mana "aku tidak tahu" bukan error, tapi bagian dari prosesnya.

Malam adalah satu-satunya waktu yang jujur

Siang hari aku sibuk. Ada fitur yang harus dirilis, bug yang harus diperbaiki, notifikasi yang tidak berhenti. Semua itu nyata dan perlu dikerjakan.

Tapi malam — malam adalah milikku sendiri.

Di situlah aku mulai menulis. Bukan dengan tujuan tertentu. Bukan dengan target kata. Hanya duduk, dan membiarkan sesuatu keluar.

Beberapa malam yang keluar hanya beberapa baris. Beberapa malam tidak ada apa-apa. Tapi ada malam-malam ketika aku menulis sesuatu dan merasa — ini. Ini hal yang selama ini tidak bisa kuucapkan dengan cara lain.

Dua bahasa, satu orang

Orang-orang sering bertanya: bagaimana bisa kamu developer sekaligus nulis puisi?

Pertanyaan yang lebih tepat mungkin: bagaimana bisa kamu tidak?

Keduanya adalah cara untuk membuat sesuatu dari kekosongan. Keduanya dimulai dari pertanyaan yang belum ada jawabannya. Keduanya membutuhkan kesabaran untuk duduk dalam ketidakpastian sampai sesuatu menjadi jelas.

Bedanya — kode selesai ketika berjalan. Puisi selesai ketika terasa.

Lalu jadilah buku

Setelah cukup lama menulis di malam hari, aku punya sekumpulan kata yang tidak tahu harus pergi ke mana.

Aku susun. Aku baca ulang. Aku hapus yang tidak jujur, aku pertahankan yang terasa benar.

Jadilah Hening yang Berjalan — buku puisi pertamaku. Dua puluh empat puisi yang dibagi dalam tiga bagian: Akar, Tumbuh, Langit. Sebuah perjalanan yang tidak menawarkan kesimpulan, hanya menemani.

Aku tidak menulisnya sebagai seseorang yang sudah sampai. Aku menulisnya sebagai seseorang yang masih berjalan.

Mungkin kamu juga pernah di titik itu.

Kalau kamu penasaran, bukunya ada di sini: cahyanudien.site/hening-yang-berjalan

Dan kalau kamu juga seorang developer yang diam-diam menyimpan sesuatu — mungkin sudah waktunya dikeluarkan.

Cahyanudien Aziz Saputra adalah pendiri FlagoDNA, pengembang aplikasi yang belajar mandiri. Banyak orang memakai apa yang ia buat. Tidak ada yang tahu berapa malam ia habiskan dalam sunyi. Buku ini adalah salah satu caranya berbicara.

The HadisKu Website Needed a Redesign. So I Did It.

Cahyanudien Aziz Saputra — Fri, 08 May 2026 13:26:28 +0000

Being an indie developer is simple, actually.

You update this. You build that. You ship. You look at it a week later and think — hmm. Something's off. Then you fix it.

That's the whole loop.

This time it was the HadisKu website.

HadisKu is my app. A hadis library — 75,000+ hadis from 14 Imam, free, no ads, no subscriptions. I built it because I wanted it to exist. That's the only reason. No business plan. No target market. Just: this should exist, and I'm the one who can make it.

The app itself felt right. Dark, quiet, focused. The kind of thing you open at night before sleep to read something that actually means something.

The website didn't feel like that at all.

It was fine. Informative. It told you what HadisKu was. But it didn't feel like HadisKu. It felt like a readme. And I kept closing my laptop slightly annoyed about it, for months, without doing anything.

Then one weekend I just... did something.

No plan. Just a feeling.

I didn't sit down with a mood board or a color theory document.

I sat down and asked: what does HadisKu feel like?

Dark. Quiet. A little bit like opening an old book. Gold on the edges, like the border of a manuscript. Arabic text that actually looks like Arabic text, not a font that happens to support it.

So that's what I built toward. A dark background the color of a room at 3am. Gold as the accent — not flashy gold, old-manuscript gold. A headline font rooted in Arabic typography. And the first thing you see on the page? Not a description of the app. A hadis. Bukhari No. 1.

Before you read a single word about what HadisKu is, you've already read something from it.

That felt right.

The old site told you. The new one shows you.

That's the difference, honestly.

The old one said: "HadisKu is an app with 75,000 hadis from 14 Imam."

The new one just... puts the hadis in front of you. Live, from the database. Arabic text. Indonesian translation. Right there on the landing page.

You don't need to install anything to know what it is. You already felt it.

The question nobody asks about indie work

When you're building alone, you make every call.

The color. The font. The copy. Whether to add the noise texture on the background (yes) or skip it because nobody will notice (they won't, but I will). Whether the card hover animation lifts 2px or 3px.

Every single thing is yours.

That's freedom. Real freedom, not the motivational-poster kind. You answer to nobody. If something looks wrong, you change it. If something looks right, you keep it. No approval needed. No committee.

But it's also all yours when it's bad. When the site looks off for six months and you keep closing your laptop slightly annoyed — that's yours too. Nobody's going to fix it for you.

So: is that a burden or a blessing?

Honestly, both. At the same time. Always.

I think that's just what indie development is. You carry the whole thing. The weight and the freedom are the same object. You can't separate them.

And sometimes on a random weekend, you just pick it up and do the thing you'd been putting off.

The website looks better now.

On to the next thing.

HadisKu — Kitab Hadis 14 Imam. Free, no ads, no subscriptions.
Android · Windows · Linux · Web
HadisKu Web

I Was Tired of Writing the Same Logic Twice — So I Built .bridge

Cahyanudien Aziz Saputra — Thu, 07 May 2026 10:41:54 +0000

If you've ever worked on a full-stack project with Laravel on the backend and TypeScript on the frontend, you know the pain.

You write a calculateTotal() function in PHP. Then you write it again in TypeScript. Then maybe a third time for a Node.js script. Same logic. Different syntax. Three places to maintain. Three places to introduce bugs.

I got tired of it. So I built something.

The Problem

Here's a real scenario. You have a pricing function in Laravel:

public function calculateTotal(float $price, float $tax): float
{
    $total = $price * (1 + $tax);
    return $total;
}

Your frontend needs the same calculation client-side, so you write it in TypeScript:

export function calculateTotal(price: number, tax: number): number {
    let total = price * (1 + tax);
    return total;
}

Now your product manager asks you to change the formula. You update the PHP. You forget to update the TypeScript. Three weeks later, a bug report comes in because the two implementations drifted apart.

This happens constantly in full-stack PHP/JS projects. And it's not a skill problem — it's a tooling problem.

The Idea: One Source of Truth

What if you could write the logic once, in a clean neutral syntax, and compile it to whatever target you need?

That's .bridge.

function calculateTotal(price: float, tax: float): float {
  let total = price * (1 + tax)
  return total
}

Run one command:

bridge build

And you get:

PHP (Laravel-ready)

<?php

namespace App\Bridge;

class Logic
{
    public function calculateTotal(float $price, float $tax): float
    {
        $total = $price * (1 + $tax);
        return $total;
    }
}

TypeScript

export function calculateTotal(price: number, tax: number): number {
    let total = price * (1 + tax);
    return total;
}

Node.js (ESM)

export function calculateTotal(price, tax) {
    let total = price * (1 + tax);
    return total;
}

Same logic. Three targets. Zero drift.

How It Works

.bridge uses a TypeScript-like syntax that's intentionally minimal. The type system maps cleanly to each target:

`.bridge`	PHP	TypeScript
`float`	`float`	`number`
`int`	`int`	`number`
`string`	`string`	`string`
`bool`	`bool`	`boolean`

The compiler reads your .bridge files and generates idiomatic code for each target — not just a generic translation, but code that fits naturally into a Laravel class or a TypeScript module.

Getting Started in 60 Seconds

Install the CLI:

npm install -g @cas8398/bridge-cli

Create a project:

bridge new my-app
cd my-app

You get a minimal scaffold:

my-app/
├── bridge.config.json
└── src/
    └── logic.bridge

Open src/logic.bridge, write your shared logic, then:

bridge build

Your compiled files land in .bridge/php/, .bridge/ts/, and .bridge/node/ — ready to copy into your existing project or reference directly.

There's Also a Reverse Command

Already have PHP or TypeScript code you want to bring into .bridge? There's a command for that too:

bridge to-bridge .bridge/php/Logic.php

It reverse-compiles back into .bridge syntax, which you can then edit and recompile to all targets. Useful for migrating existing logic incrementally.

VS Code Support

There's a VS Code extension with syntax highlighting and snippets for .bridge files:

👉 Bridge Language Support on the Marketplace

Type func + Tab to scaffold a function. Type let + Tab for a variable. Nothing fancy, but it makes the editing experience feel native.

What It's Not

I want to be honest about scope. .bridge is not a full programming language. It doesn't handle classes, conditionals, loops, or complex control flow yet. Right now it's focused on pure functions — stateless logic that takes inputs and returns outputs.

That's actually the sweet spot for shared business logic: validation rules, calculations, formatters, transformers. The stuff you really don't want living in two places.

Why I Built It as a CLI, Not a Library

I considered building this as a Babel plugin or a TypeScript transformer, but those tie you to a specific ecosystem. A standalone CLI means you can use it regardless of your build toolchain — whether you're on Vite, Laravel Mix, plain webpack, or no bundler at all. It sits outside your stack and just generates files.

Try It

CLI: npmjs.com/package/@cas8398/bridge-cli
Source: github.com/cas8398/bridge-cli
VS Code extension: marketplace.visualstudio.com/items?itemName=FlagoDNA.bridge-vscode

It's early, rough in places, and very much a raw dev release — but the core idea works. If you've felt this pain on a PHP/JS full-stack project, I'd love to know if .bridge fits your workflow.

Built with TypeScript. MIT licensed. Feedback welcome via GitHub Issues.

Bridge: Write Logic Once, Compile Everywhere | Cahyanudien Blogs

Cahyanudien Aziz Saputra — Wed, 06 May 2026 08:34:24 +0000

Sometimes the problem isn’t complexity.

It’s repetition.

The Problem I Keep Hitting

In almost every project, I end up writing the same logic twice.

Validation rules
Price calculations
Data transformations

Once in backend (PHP),
and again in frontend (TypeScript).

It’s not hard.
But it’s fragile.

One change → forget to sync → subtle bug.

And over time, that duplication becomes technical debt.

The Idea

What if the logic itself was the source of truth?

Not PHP. Not TypeScript.

Just logic.

So I started experimenting with a small language:

function calculateTax(price: float, rate: float): float {
  let tax = price * rate
  return tax
}

Then compile it into:

PHP (for backend)
TypeScript (for frontend)
Node.js (for shared tooling)

That became Bridge.

What Bridge Actually Is

Bridge is not a framework.

It’s a CLI compiler.

Input: .bridge file
Output: real code (PHP / TS / Node)

No runtime.
No magic.

Just transformation.

Why Not Just Use JSON / Schema?

I asked myself the same thing.

Schemas are good for structure.
But logic is more than structure.

You can’t express:

calculations
conditional logic
transformations

…cleanly in JSON.

Bridge sits in that gap:

structured logic, not just structured data

What I Built

I kept it intentionally small.

Lexer → tokenize input
Parser → build AST
Compiler → generate target code

Each target has its own emitter:

PHP
TypeScript
Node.js

Nothing fancy. Just predictable output.

Example Output

Bridge:

function calculateTax(price: float, rate: float): float {
  let tax = price * rate
  return tax
}

TypeScript:

export function calculateTax(price: number, rate: number): number {
  const tax = price * rate;
  return tax;
}

PHP:

function calculateTax(float $price, float $rate): float {
  $tax = $price * $rate;
  return $tax;
}

Same logic.
Different runtimes.

Tooling (Important Part)

A language without tooling is painful.

So I built a simple VS Code extension:

syntax highlighting
snippets

👉 https://marketplace.visualstudio.com/items?itemName=FlagoDNA.bridge-vscode

And the CLI:
👉 https://www.npmjs.com/package/@cas8398/bridge-cli

Source code:

Limitations (on purpose)

Bridge is not trying to replace real languages.

Right now:

No classes
No async
No complex types

It focuses on:

small, deterministic business logic

That constraint is intentional.

What I Learned

1. Small tools are easier to reason about

The moment it tries to do everything, it becomes another language problem.

2. Determinism matters more than features

Same input → same output builds trust.

3. Most logic duplication is boring, not complex

And boring problems are perfect for automation.

Where This Might Go

Better type system
More targets (Python, Go)
Watch mode (bridge watch)
Real-world integrations

Or maybe it stays small.

That’s fine too.

Closing

Bridge is just an attempt to reduce friction.

Not a big framework.
Not a new ecosystem.

Just a small layer between logic and implementation.

If this resonates with you, try it.
Or break it. Both are useful.

The Sound of Silence: Why I Rewrote the AmalanKu Landing Page

Cahyanudien Aziz Saputra — Tue, 05 May 2026 17:01:57 +0000

Before you read on:

AmalanKu is a private, offline-first Muslim companion for istiqomah — no accounts, no ads, no tracking.

Visit amalanku.com →

The Mismatch Wasn't Broken Code. It Was Broken Tone.

I didn’t rewrite the AmalanKu website because something was broken. I rewrote it because the website was lying about the heart of the product.

As developers, we are trained to brag. We want to show off the tech stack, the seamless sync, and the clean data visualization. But AmalanKu isn't a productivity tool or a gamified habit tracker. It is a quiet, digital corner for reflection.

While the app had found its soul, the landing page was still wearing a corporate SaaS suit. It was pitching features when it should have been offering peace.

Two Layers of Subtraction

To fix the mismatch, I had to be ruthless. This wasn't just about changing headlines; it was about changing the medium itself.

1. Subtraction in Words

I killed the "marketing" language. If the app is built on the premise of Digital Zuhud (restraint), the website shouldn't sound like it's trying to hit a quarterly sales target.

❌ Removed feature-heavy checklists.
❌ Removed the "hard sell" tone.
❌ Removed buzzwords that felt like noise.

2. Subtraction in Code

I moved from Astro JS to bare HTML and CSS. Astro is brilliant, but for this project, even a modern framework felt like unnecessary "weight."

❌ Removed JS hydration and bundles.
❌ Removed analytics and tracking scripts.
❌ Kept only raw, semantic HTML.

Why Bare HTML Aligns with Istiqomah

App Value	Website Reflection
🔒 No tracking	🌐 Zero analytics or tracking cookies
📦 Offline-first	⚡ Zero JS, instant load on any network
🧘 No pressure	🎨 No animated CTAs or urgency tactics
🤲 Private by design	💾 No fingerprints, no data collection

If the app promises simplicity, the website shouldn't whisper one thing and shout another. Speed is a form of respect; a 100/100 Lighthouse score is an act of service to the user.

The New Narrative: Intention Over Metrics

I realized that by listing "Data Tracking" as a primary headline, I was accidentally telling users: "Focus on the numbers." But the goal of AmalanKu is to help users focus on the Creator, not the chart.

The new landing page follows a different flow:

Intention: "Istiqomah Dalam Setiap Amalan" — start with the Why.
Privacy: Clear, bold statements about data staying local.
Growth: Presenting the "Level Amalan" (Pemula to Berkembang) as a journey, not a task list.
Community: Real words from the Ummah, from Makassar to Jakarta.

Closing: Silence as Honesty

The AmalanKu website didn’t become better because I added "better" code. It became better because I finally learned when to shut up.

In a world where apps fight for every second of your attention, providing a space that asks for nothing and gives you back your privacy is the ultimate feature. Sometimes, the most honest way to communicate is through silence—and in web development, that silence is bare HTML.

Experience the quiet for yourself at amalanku.com.

🤲 Download on Play Store

Hijri Today: I Built This Because My Mom Needed It | Cahyanudien Blogs

Cahyanudien Aziz Saputra — Mon, 04 May 2026 06:08:22 +0000

It started with my mom.

Not a pitch deck. Not a market research document. Not a monetization strategy.

Just my mom, asking me — again — what today's date is in Hijri.

The Real Origin Story

My mom is not a tech-savvy person. She doesn't open five apps before breakfast. She doesn't maintain a productivity system. She just wants to know — is today a fasting day? What's the Hijriah date? Is Ramadan close?

Simple questions. And every single time, she had to either open a browser, dig through a calendar app, or ask someone.

I watched her do this for months before it finally clicked: this shouldn't be hard. This information should just be there, on her home screen, waiting for her — the way the clock and the weather are.

So I built it. Not because I saw a gap in the market. Because I saw a gap in my mom's morning.

That's Hijri Today — or "Hijri Hari Ini" as we say in Indonesian.

What It Does (And Why It's Different)

A lot of Islamic calendar apps exist. Most of them require you to open the app. You unlock your phone, find the icon, tap it, wait for it to load, see the date, close it, and go on with your day.

That's friction my mom doesn't need.

Hijri Today is a home screen widget. No tapping required. No opening required. The Hijriah date is just there, on your home screen, updated automatically — the same way your wallpaper clock is.

It sounds small. It isn't.

From 1.0.0 to 1.0.6: The Real Changelog

Building in public means being honest about the journey. Here's what actually changed across every release — no spin, no invented features.

🌱 v1.0.0 — It Works

The first version did one thing: show the Hijriah date on your home screen. That's it. One widget style. English and Arabic only. No customization, no settings to get lost in.

It was rough. But my mom could see the date without opening anything, and that felt like everything.

I shipped before I was ready, because the alternative was never shipping.

🔧 v1.0.1 — First Iteration

Small fixes, polish on the first release. Getting the foundation stable before adding anything new.

🛠️ v1.0.2 — Notifications & Sponsor Portal

Fixed Islamic event notifications that weren't firing correctly — which matters, because missing Eid notifications is not a minor bug. Also added a sponsor portal plugin as infrastructure for sustaining development without charging users or running ads.

🌍 v1.0.3 — Localization & Widget Overhaul

This was the first version that made me realize the app could reach beyond Indonesia.

Added localization support for 13 languages: Malay, Urdu, Bengali, Turkish, Hausa, Yoruba, Somali, French, Spanish, and Hindi — alongside the existing English, Arabic, and Indonesian.

The Islamic community doesn't live in one country. It felt wrong to keep the app feeling like it was built only for mine.

Also in this version: the widget system was refactored for improved stability, dynamic color theming was introduced, and the configurable Hijri date offset (±2 days) landed — allowing users to adjust the displayed date to match the moon-sighting authority followed in their region. A small toggle with real religious significance: the difference between showing Ramadan starting on the right day or the wrong one.

📜 v1.0.4 — Widget Scroll & Shareability

Added vertical scroll to the widget update flow to handle overflow better on different screen sizes.

Also built out a proper share message — so users who want to recommend the app to family have something worth sending:

"Hijri Today is a beautiful and lightweight Android widget displaying the current Hijri date, Islamic events, and Sunnah fasting reminders. 100% Free, No Ads, No Analytics."

That share copy is also a mission statement. It's what I want every person who finds this app to understand in 10 seconds.

🗓️ v1.0.5 — 30 Languages, Javanese Calendar, 5 Widget Styles

The biggest release. A lot moved in this one.

17 new languages added, bringing the total to 30:
Persian, Swahili, Pashto, Punjabi, Tamil, Russian, Uzbek, Kurdish, Portuguese, German, Italian, Dutch, Filipino/Tagalog, Amharic, Kazakh, Albanian, and Bosnian.

Every language represents a Muslim community that can now see their Hijri date without switching to English first.

Javanese Pasaran days landed as an optional toggle — the five-day traditional Javanese cycle (Legi, Pahing, Pon, Wage, Kliwon) shown alongside the Hijri date. My app was born in Indonesia, and Javanese Muslim culture has always carried both calendars at once. This made that official.

5 widget styles introduced: Standard, Minimalist, Jawa, Arabic, and Terpadu (Integrated). Because one design was never going to fit 30 language communities across different visual cultures.

The UI was also rolled back to the v1.0.3 design — the v1.0.4 UI experiment didn't hold up. Shipping an update sometimes means admitting the previous update was a step backwards and fixing it.

🕌 v1.0.6 — Full Islamic Events Restored & Navigation Redesign

Two things changed in this version, and both matter.

Islamic events restored in full. An earlier release had trimmed the events list down — which quietly broke something important. If you're fasting on Arafah or watching for Mawlid an-Nabi, you need the app to actually tell you. This version brought back the complete set: Ramadan, Eid al-Fitr, Eid al-Adha, Islamic New Year, Mawlid an-Nabi, Yawm Arafah, Ashura, and more.

Tab bar moved from top to bottom. Small UX change. Big difference in one-handed usability, especially on larger phones. The navigation now sits where your thumb already is.

The Philosophy Behind the Product

There are things I decided early and held firm on through every version:

Free. No hidden costs, no premium tier. The Hijriah date is not a feature — it's something every Muslim deserves access to, without a subscription.

No ads. I didn't want anyone's spiritual morning routine interrupted by a banner ad. Clean experience, always.

No unnecessary permissions. The app only asks for alarm scheduling permission — nothing else. No location tracking, no contacts, no analytics. Your phone, your data.

Lightweight. This is a widget. It should be invisible, unobtrusive, and fast. Not another battery drain.

What's Next

I don't have a roadmap to announce. What I have is a commitment to keep shipping.

Every version so far came from a real observation — something missing, something broken, something that mattered to real people using the app daily. That's how the next version will happen too.

If you use the app and something bothers you, or something's missing that should be there — leave a review. That's where the next changelog starts.

Download It

Hijri Today is available now on the Google Play Store — free, ad-free, and built with care.

👉 Get it on Google Play

To Every Muslim Who Downloads This

Barakallahu fiikum. 🤲

I hope this widget makes your morIt started with my mom.

Not a pitch deck. Not a market research document. Not a monetization strategy.

Just my mom, asking me — again — what today's date is in Hijri.

The Real Origin Story
My mom is not a tech-savvy person. She doesn't open five apps before breakfast. She doesn't maintain a productivity system. She just wants to know — is today a fasting day? What's the Hijriah date? Is Ramadan close?

Simple questions. And every single time, she had to either open a browser, dig through a calendar app, or ask someone.

I watched her do this for months before it finally clicked: this shouldn't be hard. This information should just be there, on her home screen, waiting for her — the way the clock and the weather are.

So I built it. Not because I saw a gap in the market. Because I saw a gap in my mom's morning.

That's Hijri Hari Ini — which literally means "Hijri Today" in Indonesian.

What It Does (And Why It's Different)
A lot of Islamic calendar apps exist. Most of them require you to open the app. You unlock your phone, find the icon, tap it, wait for it to load, see the date, close it, and go on with your day.

That's friction my mom doesn't need.

Hijri Hari Ini is a home screen widget. No tapping required. No opening required. The Hijriah date is just there, on your home screen, updated automatically — the same way your wallpaper clock is.

It sounds small. It isn't.nings a little simpler. I hope it helps you catch the fasting days you'd have missed. I hope it connects you, just a little more gently, to the Islamic calendar that structures so much of spiritual life.

And if it helps your mom know what day it is in Hijri — without having to ask anyone — then it's already done its job.

Built by Flagodna — small apps, real purpose.

Too Many Notifications on Android? Here’s a Better Way

Cahyanudien Aziz Saputra — Thu, 30 Apr 2026 06:03:18 +0000

Notifications are useful—until they become overwhelming.

For many Android users, phones constantly buzz with messages, promotions, reminders, social media alerts, and app updates. What should be helpful often turns into distraction, stress, and lost focus.

Many people wake up to dozens of unread notifications before the day has even started. Others struggle to concentrate because alerts keep interrupting work, study, or rest.

If this sounds familiar, you are not alone.

Why Too Many Notifications Become a Problem

Notification overload affects more than convenience.

Common problems include:

Losing focus during important tasks
Feeling pressure to check the phone repeatedly
Missing important alerts inside unimportant noise
Starting the day stressed by a crowded notification panel
Mental fatigue from constant interruptions

When every notification feels urgent, attention becomes fragmented.

A Smarter Way to Manage Notifications

Instead of reacting instantly to every alert, many users are now looking for smarter tools that help organize notifications and reduce unnecessary interruptions.

That is where Keynotif can help.

Keynotif is an Android app designed to help users regain control over notifications with a calmer and more organized approach.

How Keynotif Helps

Keynotif is built for people who want less noise and more control.

Benefits include:

Better notification organization
Fewer distractions during focus time
Easier review of alerts later
Cleaner and calmer phone experience
More control over when notifications deserve attention

Instead of letting notifications control the day, users can choose when to engage.

Built With Privacy in Mind

Notifications often contain personal information. Messages, reminders, and account alerts should be handled carefully.

That is why Keynotif is built with a privacy-first mindset for users who value simplicity and control.

Who This Is For

Keynotif may be useful for:

Students who need focus time
Professionals tired of constant interruptions
Productivity-minded Android users
Privacy-conscious users
Anyone overwhelmed by notifications

Final Thoughts

Your phone should support your attention, not constantly compete for it.

If too many notifications are making Android feel stressful, there is a better way to manage them.

Download Keynotif on Google Play:
https://play.google.com/store/apps/details?id=com.flagodna.keynotif

Keynotif (Part 3): It’s Out. | Cahyanudien Blogs

Cahyanudien Aziz Saputra — Tue, 28 Apr 2026 02:30:08 +0000

It's out.

Two weeks ago, Keynotif was just frustration with a familiar kind of morning.

You wake up.

Your phone is full of unread messages, promotions, alerts, reminders, group chats, and things you never asked to care about.

Before you've even stood up, your attention already belongs to everyone else.

That feeling stayed with me.

So I built something for it.

Today, Keynotif is live on the Play Store.

The real problem isn't notifications

Notifications are not always the enemy.

Some matter.

Some are useful.

Some are genuinely important.

The real problem is that they all arrive looking equally urgent.

A family message can sit beside a discount promo.

A banking alert can sit beside a random app begging for engagement.

Everything asks for attention in the same voice.

So people keep checking.

Not because they love notifications.

Because they don't want to miss the one thing that matters.

That uncertainty is expensive.

It steals mornings in small invisible ways.

Why mornings matter

Morning attention is different.

It's softer.

Less defended.

More valuable.

What happens in the first few minutes of the day often sets the tone for everything after it.

Yet millions of people begin by sorting digital clutter.

Open one app.

Then another.

Reply to something small.

Read something unnecessary.

Lose ten minutes.

Lose mental clarity.

Start reactive.

I wanted another option.

What Keynotif does

Keynotif is built for that first moment of the day.

Instead of checking multiple apps one by one, you open Keynotif and get a cleaner digest of what happened while you were away.

Not every detail.

Not endless scrolling.

Just enough context to understand what matters first.

Think of it less like an inbox.

More like a morning briefing.

Designed to feel light

I didn't want another dashboard.

I didn't want something that required setup tutorials or productivity rituals.

I wanted this flow:

Open app.

Understand morning.

Move on.

That's why Keynotif stays intentionally simple.

You can read the digest quickly.

Or tap play and let text-to-speech read it aloud while you make coffee, shower, or get ready.

Technology should sometimes get out of the way.

Privacy had to come first

Notifications contain real life.

Names.

Messages.

Security codes.

Delivery updates.

Financial alerts.

Private conversations.

That means any product touching notifications should treat them carefully.

AI Processing & Anonymization

When AI summarization is used, notification content is sanitized before processing.

Sensitive values are replaced with placeholders such as:

user@email.com

→ [EMAIL-XXX]

https://example.com/link

→ [LINK-XXX]

+62 812-3456-7890

→ [NUM-XXX]

OTP: 847291

→ [NUM-XXX]

The goal is straightforward:

Useful summaries without exposing unnecessary personal information.

No drama.

No surveillance mindset.

No pretending privacy doesn't matter.

What you get right now

Morning digest

A calmer summary of overnight activity.

Text-to-speech

Useful when you don't want to stare at a screen immediately.

VIP contacts

Choose people whose notifications should stand out.

Category controls

Reduce repeat noise from apps you already know are low value.

Lightweight experience

No ads. No clutter. No endless feeds.

Why I built it in two weeks

Because speed creates truth.

You can debate ideas for months.

You can sketch features forever.

You can optimize something no one needs.

But once people use a product, reality becomes visible.

So I gave myself two weeks.

Enough time to build something real.

Not enough time to hide behind perfectionism.

That constraint helped.

It forced decisions.

It removed vanity work.

It kept focus on usefulness.

What I learned

Building quickly reminded me of something important:

Most products become worse when they try to impress.

Too many features.

Too much interface.

Too many ideas added before the first idea is proven.

Simple is difficult because it requires saying no repeatedly.

Keynotif became better every time I removed something unnecessary.

What's next

Launching is only the start.

Now comes the valuable phase: observing real usage.

I already know where I want to improve.

Smarter spam and promo blocking

A large number of notifications are predictable noise:

flash sales
repeated promotions
low-value reminders
aggressive re-engagement attempts

Future versions should automatically detect and suppress these patterns.

Better AI summaries

I want summaries to become:

more accurate
more natural
more context-aware
easier to scan in seconds

Not flashy AI.

Reliable AI.

Priority notifications

Some things deserve higher visibility:

family
urgent contacts
banking alerts
deliveries
work-critical messages

The app should help surface what likely matters first.

Personal relevance

Over time, Keynotif may learn what you consistently ignore and what you always care about.

Only to reduce friction.

Not to manipulate behavior.

Staying small on purpose

Just as important as future features is what I do not want this to become:

another ad machine
another attention trap
another bloated productivity app
another noisy tool pretending to solve noise

The mission stays simple:

Help people start the day with clarity.

Why you might try it

If your mornings often begin like this:

unlock phone → open five apps → scan everything → feel behind

Then Keynotif may be useful immediately.

Not because it changes your life.

Because it removes one daily point of friction.

Sometimes that is enough.

It's live

Two weeks ago, this existed only as annoyance.

Now it's real software used by real people.

That still feels meaningful to me.

Play Store:

https://play.google.com/store/apps/details?id=com.flagodna.keynotif

Website:

https://keynotif.web.app

Android only. Free. No ads.

Just a calmer way to start the day.

#buildinpublic #android #digitalwellness #productivity #privacy #keynotif #flagodna

Keynotif (Part 2): The Part That’s Actually Hard | Cahyanudien Blogs

Cahyanudien Aziz Saputra — Sat, 11 Apr 2026 05:03:40 +0000

A few days ago, I wrote about the problem.

Waking up.

Opening your phone.

Not knowing what actually matters.

That part hasn’t changed.

What changed is this:

Now I have something running on my phone.

And it’s… quieter.

Not smart.

Just quieter.

The same morning, slightly different

Phone screen.

Still lights up.

Still a list.

But smaller.

Some things are just… gone.

System noise.

Random background notifications.

Stuff I already know I don’t care about.

And for a second, it feels better.

Lighter.

But then the same question comes back:

Is anything here actually important?

And I still don’t know.

That’s the gap.

That’s the part I haven’t solved yet.

What exists right now

I didn’t start with AI.

I started with control.

So what’s built is mostly foundation:

Basic UI (kept intentionally quiet)
Local database (everything stays on device)
A simple app flow:
- onboarding
- morning page
- all notifications
- settings

Nothing fancy.

Just enough to run the idea end-to-end.

What the app actually does

Right now:

It listens to incoming notifications
Removes obvious noise (system, low-signal stuff)
Lets me define what to ignore
Stops completely if DND is active

No intelligence.

No ranking.

No decisions.

Just reducing the mess.

And honestly, even that helps.

But it doesn’t solve the real problem.

The real problem (still)

It’s not volume.

It’s uncertainty.

Even with fewer notifications, I still hesitate.

Still scan.

Still second-guess.

Because “less noise” is not the same as “clear signal”.

Where this gets difficult

The next step sounds simple:

Figure out what matters.

It’s not.

Because “important” is not a fixed rule.

It changes:

based on who it’s from
when it arrives
what’s happening in your life
what you’re expecting that day

You can’t hardcode that.

What I’m building next

Two parts.

Both uncomfortable.

1. On-device anonymizer

Before anything leaves the phone:

Strip identity
Reduce messages into patterns
Turn them into abstract signals

Not:
"John: call me now"

More like:
someone important + unusual time + direct request

2. Decision layer

Somewhere (likely server-side):

Learn what I actually respond to
Detect urgency vs routine
Return a simple answer

Not a feed.

Not a summary.

Just:

this mattered

The part I don’t trust yet

This is where I’m careful.

If the system gets this wrong, even occasionally:

I stop trusting it
I go back to checking everything
The whole thing collapses

So accuracy matters more than features.

And predictability matters more than intelligence.

Still chasing the same thing

Nothing changed from the first post.

I don’t want better notification management.

I want this:

You wake up.

You look once.

You know.

That’s it.

It’s Simple, But Annoying: Why I Started Building Keynotif | Cahyanudien Blogs

Cahyanudien Aziz Saputra — Thu, 09 Apr 2026 05:33:23 +0000

Most notification systems ask the same thing from you.

Your attention. Your reflex. Your mornings.

Not because they’re malicious by design — but because they’re built around delivery, not discernment.

Every ping arrives with the same urgency.

A message from your mother. A random promo email. A group chat meme. A missed opportunity. A meaningless badge count.

And when you wake up, you don’t know which is which.

That’s the real problem.

It’s simple, but annoying

The problem with your morning isn’t your alarm. It’s what happens after.

I remember the exact morning.

6:47 AM. I reached for my phone before I even sat up in bed.

Habit. Reflex. Something I’d done so many times it stopped feeling like a choice.

The screen lit up.

WhatsApp: 34 unread

Email: 12 new messages

Instagram: someone liked an old photo

Slack: three messages from a group I forgot I joined

Twitter: a reply I never asked for

I lay there, scrolling.

Not looking for anything specific. Just processing. Consuming. Clearing.

Twenty minutes passed.

I hadn’t gotten up yet.

I hadn’t had water.

I hadn’t had a single thought of my own.

And I still didn’t know if anything actually mattered.

This is not a productivity problem

The first thing people say when you describe this is:

“Just turn on Do Not Disturb.”

I tried that. Most people have.

The problem with DND is that it doesn’t solve anything. It just moves the problem.

You sleep undisturbed.

You wake up.

You turn it off.

And the same flood is waiting for you.

Forty notifications.

No idea which ones matter.

Same twenty minutes.

Same exhaustion.

DND is a pause button.

What I needed was a filter.

There’s also a subtler issue nobody really talks about:

You can’t fully ignore your notifications. Not really.

Because somewhere in that pile might be:

your mother
your partner
an emergency
something that actually required your attention at 2 AM

…and it got buried under eleven promotional emails and a group chat about weekend plans.

So you don’t mute everything.

You leave it on.

You check.

You get pulled in.

You feel guilty about the time you just lost.

Tomorrow comes.

The cycle repeats.

The data behind the feeling

At first, I assumed this was a personal problem.

A discipline problem.

A self-control problem.

Something I should just “fix” about myself.

Then I started looking at the numbers.

The average person receives dozens of notifications per day — and for younger users, that number can become overwhelming fast.

A lot of people already use:

Do Not Disturb
Focus Mode
app silencing
notification muting

In other words:

People already know the problem exists.

They’re already trying to manage it.

And yet the anxiety remains.

Because the problem was never just volume.

It was uncertainty.

The not knowing.

The awareness that something important might be in there somewhere, buried under everything that isn’t.

That uncertainty is what keeps you checking.

Not curiosity.

Not weakness.

Not “bad habits.”

Just a completely reasonable fear that you might miss something that matters.

What I actually wanted

I started writing down what my ideal morning would feel like.

Not a feature list.

Just a feeling.

I want to wake up and know if someone important reached out.
I want to know if something urgent happened while I slept.
I don’t want to see everything else until I’m ready for it.

That’s a small ask.

It sounds almost trivially simple.

But no app I could find actually did it the way I meant.

Most notification managers are really just organizers.

They sort the flood into buckets.

You still have to wade through everything — it’s just arranged more neatly.

Others are focus tools.

Useful, yes.

But they’re designed to block distraction while you work.

That’s not the same problem.

What I wanted was something that worked while I slept.

Something that watched the incoming stream, made decisions quietly in the background, and greeted me in the morning with only what mattered.

One screen.

Calm.

Done.

I looked for that app longer than I’d like to admit.

So I started building it

I’m a solo developer.

I build under FlagoDNA — mostly tools I make because I need them and can’t find them elsewhere.

Things like:

local-first tools
privacy-first utilities
focused apps without unnecessary complexity
products that respect constraints instead of pretending they don’t exist

This felt like the same kind of problem.

Personal.

Specific.

Worth solving properly.

I don’t know yet if what I’m building is the right answer.

I’m still in it.

Still testing assumptions.

Still finding edge cases I didn’t anticipate.

But the core idea is clear.

A native Android app that watches your notifications while you sleep — and greets you in the morning with only what matters.

I’m calling it Keynotif.

Why this matters to me

I’m not trying to build another “productivity app.”

I’m trying to build something calmer than that.

Something that respects the fact that the first minutes of your day shape everything after them.

If the first thing you experience is noise, urgency, and ambiguity, your brain starts the day in defense mode.

If the first thing you experience is clarity, that changes everything.

That’s what I’m chasing.

Not more control.

More signal.

Less friction.

A better default.

Build in public, honestly

I’m still early.

There are still open questions:

How should “importance” be defined?
Should urgency be rule-based, contextual, or user-trained?
How much automation is helpful before it feels invasive?
Can this stay private-first and still be genuinely smart?

Those are the interesting questions.

And honestly, that’s why I’m sharing this now.

Not because it’s finished.

Because it isn’t.

Does this sound like something you’ve needed?

If you’ve ever lost 20 minutes to a notification pile before your feet even touched the floor, then you probably understand exactly why I’m building this.

And if you’ve solved this in your own way, I’d genuinely like to hear how.

Not for validation.

For signal.

You can drop a comment or find me at cahyanudien.site.

#buildinpublic #androiddev #digitalwellness #productivity #keynotif #flagodna

Originally published at https://blog.cahyanudien.site on April 9, 2026.