DEV Community: Vlad B.

This week at Romi #3 - Building Multi-Platform App Connectivity

Vlad B. — Sun, 27 Sep 2026 01:34:13 +0000

When we first launched our app, simplicity was our guiding light. We started with the absolute basics, built our core features, and steadily grew our user base. But as any developer scaling an application knows, user growth brings new expectations and friction points.

If users encounter friction during authentication or onboarding, they drop off. Over the past couple of years, our approach to app connectivity and authentication evolved significantly to meet our users where they are.

Here is a look back at our journey of adding sign up and calendar connection methods step by step.

Phase 1: The Foundation (Email and Password)

In the first couple of months, we kept authentication as straightforward as possible. We relied solely on traditional email and password sign ups.

Why we started here: It required the least amount of external configuration, let us build our core database schema quickly, and gave us full control over user credentials.
The drawback: Users hate remembering new passwords. Conversion rates suffer when people have to type in a long password and verify their email just to test a new tool.

Phase 2: Expanding for Convenience (Google and Calendar)

As our product matured, we wanted to reduce friction and tap into daily workflows. We added Google signup and Google Calendar integration.

The impact: Conversion rates jumped immediately. Allowing users to log in with a single click removed a major barrier to entry.
The workflow benefit: Because our product relies heavily on scheduling, connecting Google Calendar let users see their events and data inside the app instantly without manual data entry.

Phase 3: Embracing the Apple Ecosystem

As we developed our mobile and desktop apps, user demographics shifted. A large portion of our user base lives inside the Apple ecosystem and prefers to keep their workflows tied to their Apple ID.

The fix: We implemented Sign in with Apple.
Why it mattered: Apple users expect native, privacy-focused login options. Adding this significantly improved our mobile onboarding experience and aligned our apps with platform expectations.

Phase 4: Going Enterprise (Microsoft and Outlook)

Lately, we have been moving into corporate support. When selling to businesses, we quickly noticed that a massive percentage of companies use Microsoft accounts for work.

To break into this market, we needed Microsoft login and Outlook calendar support. However, integrating enterprise authentication is rarely plug and play.

The verification hurdle: Getting verified through the Microsoft Partner Program was a real struggle. It involved navigating complex compliance requirements, submitting documentation, and waiting for manual reviews.
The payoff: After a week of hard work and patient waiting, our verification finally succeeded. Now, corporate users can log in seamlessly using their work credentials and sync their Outlook calendars without a hitch.

What We Learned

Building flexible app connectivity is a journey that scales alongside your product.

Start simple: Email and password are fine for day one when you are validating an idea.
Follow your users: Add social logins (Google and Apple) once you need to lower friction and improve consumer conversion.
Invest in enterprise readiness: If you want to move upmarket, tackling complex compliance and integrations like Microsoft is worth the administrative headache.

Today, our app can successfully serve individuals and teams across multiple platforms and ecosystems. What authentication providers do you prioritize when building a new product? Let me know in the comments below!

What If Your Terminal Had an Infinite Canvas? Meet Fuse.

Vlad B. — Thu, 17 Sep 2026 02:09:44 +0000

Let’s be honest: every software project eventually grows a collection of messy, fragile shell scripts.

You know the drill:

A 200-line release script that occasionally breaks mid-execution.
Juggling three terminal tabs to run migrations, build artifacts, bump versions, and deploy across different sub-projects.
Forgetting a parameter or copy-pasting an API token into the wrong prompt.

I wanted something that gave me the visual clarity of node-based automation tools (like Blender shader graphs or visual CI pipelines), but running 100% locally on my Mac, with zero cloud lock-in, and without an Electron app eating 1GB of RAM.

So I built Fuse — an open-source, native visual command and workflow builder for macOS.

VladB-evs / Fuse

Visual command and workflow builder for macOS. Connect shell commands, scripts, APIs, Git operations, and logic into executable workflows.

Fuse

Visual Command & Workflow Builder for macOS

Draw your terminal commands as connected blocks on an infinite canvas.
Orchestrate complex shell scripts, APIs, git workflows, and automated pipelines with real-time streaming output, smart variables, and Apple on-device intelligence

Key Features • Quick Start • Block Catalog • Variables & Flow • Shortcuts • Architecture

(the actual image of the worlflow used for this app)

⚡️ Key Features

🎨 Fluid Canvas Orchestration — Built for speed. Add blocks with a keystroke, drag wires between ports, and let frames auto-resize around their contents.
🦀 Native Rust Performance — Zero Electron bloat. Powered by Tauri 2 and Tokio async DAG walk. Sub-50MB memory footprint with instant launch times.
🧠 Apple On-Device Intelligence — Analyze git diffs locally using on-device semantic summaries to generate conventional commit messages in milliseconds.
📁 Repository & Folder Frames — Group blocks inside folder frames. Every block inside…

View on GitHub

What is Fuse?

Fuse lets you draw terminal commands, scripts, and API calls as connected nodes on an infinite canvas. You connect blocks with wires, pass variables downstream, set up conditionals, and watch real-time streaming ANSI terminal outputs as your DAG (Directed Acyclic Graph) executes.

Why Not Just Run Shell Scripts?

Here is what makes workflow graphs in Fuse fundamentally different from chaining && in a terminal:

1. Multi-Repo "Folder Frames"

Working on a monorepo or separate client/server repositories? You can drop a Folder Frame on the canvas and bind it to a local directory. Any block placed inside that frame automatically executes within that directory. You can coordinate your backend, frontend, and Docker setups on a single screen.

2. Smart Variable Piping (Without Escaping Nightmares)

Outputs from upstream blocks are automatically captured and bound into your workflow context:

Upstream: git rev-parse --short HEAD -> {{sha}}
Upstream: Semantic version bumper -> {{next_version}}
Downstream: Use them in curl payloads, shell commands, or commit messages:

git commit -m "chore(release): bump to {{next_version}}"
git tag "{{next_version}}"

Fuse handles shell-safe escaping under the hood so spaces, quotes, and multiline inputs won't break your commands.

3. Human-in-the-Loop Controls

Workflows shouldn't always be a blind "run and pray":

Confirm: Pauses execution and asks for approval before critical actions (like git push --tags or a production deploy).
Ask: Prompts you mid-run for a one-time value or secret token (with password masking).
Choose & If (Condition): Branch your execution paths dynamically based on exit codes or interactive user selections (e.g. [Deploy Staging] vs [Deploy Production]).

4. The "Laser Slicer" (Because UX Matters)

Instead of meticulously clicking wires to delete them, hold Ctrl and slice your cursor across connections or nodes like a laser blade to sever them instantly.

5. Native Rust Performance (Sub-50MB RAM)

Fuse is built on Tauri 2 and Rust with Tokio async processes. It starts up instantaneously, doesn't spin up heavy Chromium browser instances per window, and uses virtually no background idle resources.

The Block Catalog

Fuse comes with a modular set of blocks you can place with a single keypress (Tab or A):

Category	Blocks
Execution	Command (shell), Script (multi-line Python/Node/Bash), HTTP Request (REST calls)
Git & Release	Bump Version (SemVer major/minor/patch), Git Presets (Init, Rebase, Tag, Push)
Data & Files	Capture (stdout to variable), Set Variable, Read File, Write File, Ask (user input)
Flow & Logic	If (Condition), Choose, Confirm, Wait (delay or healthcheck polling), Frame

Tech Stack

Under the hood, Fuse is built with modern web and systems tech:

Frontend: React 19, TypeScript, @xyflow/react (React Flow), Tailwind CSS v4, Lucide Icons.
Backend / Desktop Shell: Tauri 2 + Rust.
Runtime: Tokio asynchronous process groups, streaming ANSI terminal output with 256-color support.

Try It Out!

If you are on macOS (Apple Silicon or Intel), you can grab the pre-built .dmg directly from GitHub Releases:

Download the latest release from GitHub Releases.
Open the .dmg and drag Fuse.app into your Applications folder.

(Note: As an open-source release without an Apple Developer certificate, if Gatekeeper gives you a prompt, run xattr -cr /Applications/Fuse.app or right-click the app and choose **Open).

Or Build from Source:

git clone https://github.com/VladB-evs/Fuse.git
cd Fuse
npm install
npm run tauri dev

I’d Love Your Feedback!

Fuse is completely open source under the MIT License.

⚠️ A Quick Note: Early Beta & Use at Your Own Risk

Because Fuse executes real shell commands, scripts, and file operations directly on your local system with your user permissions:

This is an early active beta (v0.1.x): Expect bugs, UI rough edges, and evolving features as the project matures.
Use at your own risk: Always double-check your connections and test commands (especially destructive operations like rm, file writes, or git resets) on test repositories or dummy files first.
Back up your work: Make sure critical code is committed and pushed before running new automated pipelines. Your bug reports and early feedback during this phase are hugely appreciated and will directly help shape the app!

This week at Romi #2 - Latency and Voice AI

Vlad B. — Tue, 08 Sep 2026 04:23:59 +0000

Welcome back to ~~This~~ Last week at Romi. We've been really busy so this post hits a bit late than our scheduled Friday one!

In Voice AI, saving 200–300 milliseconds sounds tiny on paper. In practice, it’s the difference between an awkward robotic delay and a natural conversation.
This week, we took a hard look at our pipeline to eliminate latency and clean out old code that was getting in the way. Here is what we changed:

Sync to Async Tools: Originally, tool execution was synchronous. When a user created a task, the pipeline froze waiting for database writes. Making our tools asynchronous means the voice keeps flowing naturally while items are saved in the background.
7 Dedup Layers Down to 2: To stop duplicate tasks from hitting the database, we kept piling on safeguards over time until we had 7 layers of deduplication. They slowed down the pipeline and began contradicting each other. With stronger prompt reinforcement and a quick backend cleanup, we cut that down to just 2 layers.
Ditching "Thinking" Models: Since our agent relies heavily on fast tool calls, thinking models added unnecessary reasoning delay before speaking. We swapped to a model optimized strictly for speed and accurate tool invocation.
Push-to-Talk Toggle: To complement these backend speedups, we added a toggle between Natural Flow and Push-to-Talk. Now users can think out loud or speak in noisy rooms without the model prematurely triggering unwanted tasks.

Sometimes performance wins aren't about writing complex new code—they're about deleting redundant safeguards, running tasks in the background, and picking the right model for the job.

What's the worst bit of legacy "safety code" you've had to clean out of your stack?

By Vlad - CTO@RomiADHD

This week at Romi #1 - OTA updates

Vlad B. — Sat, 29 Aug 2026 06:21:04 +0000

We finally added OTA updates to Romi.

This is something apps have been doing for years, but it’s new territory for us.

Instead of waiting for Apple’s review every time we need to push a small fix, we can now ship certain updates directly to users.

And because apparently paying for another service wasn’t exciting enough, we built our own setup using Capgo + CDN.

It’s one of those things that feels obvious once it works. Getting there was slightly less obvious. 😅

What’s something your team implemented way later than everyone else?

By Vlad - CTO@RomiADHD

I Built an Obsidian Plugin for Myself. Someone Actually Used It.

Vlad B. — Sat, 29 Aug 2026 04:26:47 +0000

I got an email recently from someone asking if I could add a feature to one of my Obsidian plugins.

The funny part? I built the plugin for myself and never really expected anyone to use it.

The plugin adds folder backlinks to Obsidian, since Obsidian only supports backlinks to notes.

He asked if I could make folder links work inside note properties because he couldn't figure out how to do it himself.

So I built it.

It's now a two-step command palette action: select the folder, then select the note property, and the link gets added.

While I was working on it, I also found a few things that weren't as smooth as they should be, fixed a couple of bugs, and polished some of the rough edges.

It's kind of weird seeing someone use something you built purely because you wanted it yourself.

Maybe I should start taking my side projects a little more seriously.

Hello from Romi!

Vlad B. — Thu, 27 Aug 2026 04:51:57 +0000

Hey this is Vlad, the CTO. We’ve been quietly building Romi for a while, so we figured it was probably time to stop hiding in the codebase.

Romi thinks like you do. Voice-first, ADHD-first. Capture thoughts, build routines, and actually stick to them. Your brain deserves a companion that keeps up.

I'm not trying to promote anything but to share what we’re building, the things we learn along the way, technical decisions, experiments, and probably a healthy amount of “well, that broke.”

We’re especially interested in exploring what happens when AI becomes something you actually work with every day, rather than just another chatbot in a browser tab.

If you’re building with AI, working on developer tools, or just enjoy watching other developers make questionable architectural decisions, welcome.

Ask me anything in the comments.

I Finally Joined DEV.to

Vlad B. — Thu, 27 Aug 2026 04:10:55 +0000

Well, I finally joined DEV.to.

Got bored of social media and scrolling so I decided to give this a go and scroll some more.

I’m currently working on Romi, experimenting with AI agents, and finding increasingly questionable ways to make computers do what I don't want to do.

I’ll probably post about what I’m building, cool open source stuff I find and maybe show off some of my (not so great) side projects.

Anyway, If you saw this tell me your best programming joke that will kill on slack lol 🗿