DEV Community: Cahyanudien Aziz Saputra

I Got Tired of Writing the Same Flutter Code Over and Over, So I Made a Package (flow_nav)

Cahyanudien Aziz Saputra — Wed, 03 Jun 2026 04:11:22 +0000

The app worked. But only on phone.

Every Flutter project I started ended up the same way.

I'd build something, it'd look great on my phone, and then I'd open it on a tablet or resize the window on desktop — and it'd just be this sad, stretched list taking up the entire screen. One column. No sidebar. No detail panel. Just vibes.

So I'd go fix it. And that's where the real pain started.

The if-else spiral

You've seen this code. You've probably written it too.

if (MediaQuery.of(context).size.width > 1024) {
  // desktop layout
} else if (MediaQuery.of(context).size.width > 600) {
  // tablet layout
} else {
  // phone layout
}

Fine for one widget. But then you need it in the AppBar. And the navigation logic. And the detail panel. And the sidebar. And the FAB visibility. And before you know it, every file in your project has this same conditional sitting inside build(), each with slightly different magic numbers.

600. 720. 1024. 800. Scattered everywhere. Not one source of truth.

And when the designer says "actually let's change the tablet breakpoint to 680" — you grep through 15 files and pray you got them all.

Then I tried existing packages

There are some good ones out there. But most of them came with opinions I didn't ask for.

They'd give me a NavigationRail I didn't want. Or a Drawer that looked nothing like my app. Or a pre-built scaffold that handled layout but had no answer for navigation — so I still had to wire up the push/pop myself and figure out when to show a detail panel vs when to push a new route.

The packages that handled layout didn't handle navigation.

The ones that handled navigation didn't handle layout.

None of them cared about my router.

I was using GoRouter. The package assumed Navigator.push. I'd end up writing adapter code just to make the two talk to each other, which kind of defeats the point.

The navigation thing was the worst part

Here's the scenario I kept running into:

User taps an item in a list.

On phone: push a new route, full screen.
On tablet/desktop: swap the detail panel on the right. Don't push anything.

Simple concept. But the code to handle this correctly — accounting for screen size, calling the right navigation method, keeping the detail panel state in sync — ended up being this tangled mess that lived in every single screen that had a list.

Every. Single. One.

I'd copy-paste it, tweak it slightly, forget to update one of the copies, and end up with bugs that only appeared on tablet. The kind that slip past testing because you test on your phone.

So I pulled it all out

I started extracting this logic into a shared utility. Then the utility grew. Then I realized it was basically a mini framework for adaptive Flutter apps — and other people probably needed it too.

That became flow_nav.

The idea is simple: you describe your layout once, and the package figures out what to do based on screen size. You don't write breakpoint checks. You don't wire up navigation conditionals. You just tell it what your body is, what your detail panel is, what your sidebar is — and it handles the rest.

FlowScaffold(
  appBar: FlowAppBar(
    title: Text('My App'),
    toolbarWidget: MyDesktopToolbar(),
  ),
  body: MyListView(
    onItemTap: (item) {
      FlowNavController.open(
        context: context,
        builder: (_) => DetailPage(item: item),
        onDetailOpen: (w) => setState(() => _detail = w),
      );
    },
  ),
  detailPanel: _detail,
  sidebar: MySidebar(),
)

On phone, sidebar is ignored, detailPanel is ignored, tapping an item pushes a new route.

On tablet, you get a split view — list on the left, detail on the right.

On desktop, you get three columns — sidebar, list, detail.

One widget. All three layouts.

It doesn't touch your UI

This was the thing I was most careful about.

flow_nav has no default styles, no pre-built components, no color scheme, no navigation rail, no drawer chrome. It provides zero UI opinions. Your AppBar looks like your AppBar. Your sidebar looks like whatever you pass in. Your detail panel is just a widget.

The package handles when and where things appear. You handle what they look like.

That also means it doesn't care about your router. You can plug in GoRouter, GetX, AutoRoute, or just the plain Navigator:

// GoRouter
FlowNavConfig.init(
  onPush: ({required context, required builder, fullscreenDialog = false}) {
    context.push('/detail');
    return Future.value(null);
  },
  onPop: (context) => context.pop(),
);

Set it once in main.dart and forget it. FlowNavController.open() will use your router on phone and skip it entirely on larger screens.

What it looks like across screen sizes

	Phone	Tablet	Desktop
AppBar	Standard	Toolbar in split view	Toolbar above content
Layout	Single column	List + Detail	Sidebar + List + Detail
Navigation	Full-screen push	Detail panel swap	Detail panel swap
Bottom nav	✅	❌	❌

Is it perfect?

No. It's 1.0.0.

There are things I want to add — better animation when the detail panel swaps, a more flexible column sizing API, maybe some helpers for common empty states. If you use it and run into something rough, open an issue. I'll actually look at it.

Where to get it

dependencies:
  flow_nav: ^1.0.0

pub.dev: pub.dev/packages/flow_nav
GitHub: github.com/cas8398/flow_nav

If it saves you from writing one more MediaQuery.of(context).size.width > 600 check, it did its job.

JDU — Jira Desktop Unofficial: I Got Tired of Opening Jira in My Browser. So I Built a Desktop App.

Cahyanudien Aziz Saputra — Sun, 31 May 2026 02:31:24 +0000

Every developer has that one browser tab that never closes.

For me, it was Jira.

It lived somewhere between Gmail and Stack Overflow, buried under 20 other tabs — waiting for me to accidentally close it and lose the URL I'd typed in three times that morning. One day I just got fed up. Not with Jira itself, but with the friction of running it inside a browser.

So I built JDU — Jira Desktop Unofficial. A lightweight, dedicated Jira desktop app built with Tauri and Rust.

Why I Built JDU (Jira Desktop Unofficial)

Nothing is technically wrong with Jira's web interface. It works fine. But keeping it inside a browser tab means:

It competes with 20 other tabs for your attention
Chrome silently "memory-saves" the tab and you lose your place
There's no dedicated window you can Cmd+Tab into directly
Every browser update is one more thing that could quietly break your workflow

What I wanted was simple: Jira in its own window. Nothing else.

Why Tauri — and Not Electron?

This is the first question everyone asks.

Electron is the obvious choice. It's popular, well-documented, and battle-tested. But Electron ships an entire Chromium browser engine inside every app — 100MB+ just to render a webpage. That's like buying a cargo ship to deliver a letter.

Tauri takes a smarter approach. It uses the webview that's already installed on your OS — WebView2 on Windows, WebKit on macOS and Linux. The backend is written in Rust. No bundled browser. No bloat.

The result speaks for itself:

Metric	JDU (Jira Desktop Unofficial)	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

~8 MB download. ~80 MB RAM. Under 2 seconds to launch.

For an app I have open all day, every day — those numbers matter a lot.

What JDU Does (and Doesn't Do)

JDU is a thin wrapper, not a reimplementation of Jira. It gives Jira its own window and gets out of the way.

✅ Works with any Jira instance — Cloud, Server, or Data Center

✅ Remembers your Jira URL and window preferences across sessions

✅ Dedicated desktop window, completely separate from your browser

✅ Zero telemetry, zero tracking, zero data collection

✅ Native OS feel — respects system themes

✅ MIT licensed and fully open source

❌ Not affiliated with or endorsed by Atlassian

❌ Doesn't handle your credentials — Jira's own login system does, exactly like a browser

❌ Multi-account support isn't here yet (it's on the roadmap)

Your login. Your data. Your workflow. JDU just gives it a proper home.

Installing JDU

Download is available for Windows, macOS, and Linux from the GitHub releases page.

Prefer to build from source? You'll need Rust, Node.js, and the Tauri prerequisites:

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

The Honest Part

This isn't a revolutionary product. It's a small tool that solves a specific, annoying problem.

I built it because I wanted it to exist. I published it because maybe you do too. The source is on GitHub, the license is MIT, and issues and PRs are genuinely welcome.

If you've ever wished Jira had a real desktop app — JDU (Jira Desktop Unofficial) is the Jira desktop client that Atlassian never built. Free, open source, and under 8 MB.

Try JDU:

Three Phases Everyone Goes Through But Nobody Talks About: Roots, Growth, Sky

Cahyanudien Aziz Saputra — Mon, 18 May 2026 15:16:52 +0000

Have you ever felt stuck — but couldn't point to why?

Not a work problem. Not a relationship problem. Not one specific thing you could name. Just a heaviness sitting in your chest, and you didn't know how long it had been there.

I've been there. And when I started writing poetry, I realized — this isn't a unique experience. It's a phase. And almost everyone goes through it.

We just never gave it a name.

Phase One: Roots

This is the hardest phase — because you don't yet know it's a phase.

It feels like waking up inside a cave. Dark. Quiet. You move, but the weight only gets heavier, not lighter. You ask: where is the light? But even that question feels exhausting.

A lot of people stop moving here. Not because they give up — but because they don't know which direction to move.

What's actually happening: you're putting down roots. Roots aren't visible from the outside. Roots aren't beautiful. They grow downward first, into the darkness, before the tree can stand.

This isn't regression. This is foundation.

Phase Two: Growth

This phase is more confusing than the first — because things look fine on the outside, but something inside still isn't finished.

You start moving again. There are good moments, bright moments. People say you seem better. You almost believe them.

But time doesn't stand still. It keeps moving, and you realize — you're not quite ready to keep pretending everything is comfortable. Something is growing, and growth isn't always clean.

Sometimes growing means letting go. Sometimes it means separating from an older version of yourself. Sometimes it means admitting you need more time than you thought.

That's not weakness. That's the process.

Phase Three: Sky

This isn't the phase where everything is perfect. This isn't a happy ending.

Sky is the phase where you can see further — not because the problems disappeared, but because you've climbed high enough to see that they're part of a larger landscape.

Here you start to feel grateful. Not a forced gratitude — but the kind that grows slowly, like realizing that everything heavy from before shaped who you are now.

And here you understand: this journey never really ends. You just keep walking, with different weight, with slightly more wisdom.

Why naming these phases matters

Because when you know you're in the Roots phase — you won't think you're broken.

When you know you're in the Growth phase — you won't rush to arrive.

And when you finally reach Sky — you'll look back and understand why all of it needed to happen.

These three phases are the backbone of my first poetry book, Stillness That Walks. Twenty-four poems, three parts, one journey that offers no answers — only company.

If you're in one of these phases right now, maybe there's a line in there that feels like yours.

cahyanudien.site/stillness-that-walks

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.

Tiga Fase yang Semua Orang Lewati Tapi Jarang Diakui: Akar, Tumbuh, Langit

Cahyanudien Aziz Saputra — Sat, 16 May 2026 06:58:43 +0000

Ada yang pernah merasa terjebak — tapi tidak tahu terjebak di mana?

Bukan masalah kerjaan. Bukan masalah hubungan. Bukan satu hal yang bisa ditunjuk. Hanya sebuah perasaan berat yang duduk di dada, dan kamu tidak tahu sejak kapan ia di sana.

Aku pernah di situ. Dan ketika aku mulai menulis puisi, aku sadar — ini bukan pengalaman yang unik. Ini fase. Dan hampir semua orang melewatinya.

Hanya saja tidak ada yang menyebutnya dengan nama.

Fase Pertama: Akar

Ini fase paling berat — karena kamu belum tahu ini sebuah fase.

Rasanya seperti terbangun di dalam gua. Gelap. Sunyi. Kamu melangkah tapi beban di hati semakin berat, bukan berkurang. Kamu bertanya: di mana cahaya itu? Tapi bahkan pertanyaan itu terasa menguras tenaga.

Di sini banyak orang berhenti bergerak. Bukan karena menyerah — tapi karena tidak tahu harus bergerak ke arah mana.

Yang sebenarnya terjadi: kamu sedang berakar. Akar tidak kelihatan dari luar. Akar tidak indah. Akar tumbuh ke bawah dulu, ke dalam kegelapan, sebelum pohon bisa berdiri.

Ini bukan kemunduran. Ini fondasi.

Fase Kedua: Tumbuh

Fase ini lebih membingungkan dari yang pertama — karena terasa baik-baik saja di luar, tapi di dalam masih ada yang belum selesai.

Kamu mulai bergerak lagi. Ada momen riang, ada momen gemerlap. Orang-orang bilang kamu sudah baikan. Kamu sendiri hampir percaya.

Tapi waktu tidak berdiam diri. Ia terus berjalan, dan kamu sadar — jiwa ini belum siap untuk terus berpura-pura nyaman. Ada pertumbuhan yang sedang terjadi, dan pertumbuhan itu tidak selalu mulus.

Kadang tumbuh artinya melepas. Kadang artinya berpisah dengan versi dirimu yang lama. Kadang artinya mengakui bahwa kamu butuh waktu lebih lama dari yang kamu kira.

Itu bukan kelemahan. Itu proses.

Fase Ketiga: Langit

Ini bukan fase di mana semuanya sempurna. Ini bukan happy ending.

Langit adalah fase di mana kamu bisa melihat lebih jauh — bukan karena masalahnya hilang, tapi karena kamu sudah cukup tinggi untuk melihat bahwa masalah itu bagian dari lanskap yang lebih besar.

Di sini kamu mulai bisa berterima kasih. Bukan terima kasih yang dipaksakan — tapi yang tumbuh perlahan, seperti menyadari bahwa semua yang berat dulu, membentukmu sekarang.

Dan di sini kamu sadar: perjalanan ini tidak pernah benar-benar selesai. Kamu hanya terus berjalan, dengan beban yang berbeda, dengan cara yang sedikit lebih bijak.

Kenapa penting memberi nama pada fase ini?

Karena ketika kamu tahu kamu sedang di fase Akar — kamu tidak akan mengira dirimu rusak.

Ketika kamu tahu kamu sedang di fase Tumbuh — kamu tidak akan terburu-buru untuk sampai.

Dan ketika kamu akhirnya di fase Langit — kamu akan menoleh ke belakang dan mengerti kenapa semua itu perlu terjadi.

Tiga fase ini yang menjadi tulang punggung buku puisi pertamaku, Hening yang Berjalan. Dua puluh empat puisi, tiga bagian, satu perjalanan yang tidak menawarkan jawaban — hanya menemani.

Kalau kamu sedang di salah satu fase itu sekarang, mungkin ada baris di sana yang terasa seperti milikmu.

cahyanudien.site/hening-yang-berjalan

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.

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.

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.

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.