I'm a web developer. React and TypeScript are what I'm fast in. Last month I shipped my first paid Windows app, a sticky notes app called HideNStick Notes, to the Microsoft Store.
Here's what I learned building a desktop app as a web dev: why I picked Tauri over Electron, how I handled the Rust parts without knowing Rust, and why I sold it through the Store instead of my own website.
The app
Sticky notes that live in the edge of your screen. Bump your mouse against the screen edge twice and your notes slide out. Put them away and your screen is clear again. You can pin a note to keep it open, use tabs inside a note, and press Ctrl+Alt+C to send selected text from any app straight into a note.
Why Tauri, not Electron
Most desktop apps use Electron: VS Code, Slack, Discord. But every Electron app ships its own copy of Chromium, so even a tiny app ends up at 80 MB or more.
Tauri uses the web view that's already on the computer. On Windows that's WebView2, which comes with Windows 10 and 11. So my whole installer is about 3 MB.
And I kept my stack. The UI is still React and TypeScript. Tauri doesn't care which front-end framework you use.
The pattern: Rust does the Windows part and sends an event, React listens for it.
Here's the real Ctrl+Alt+C capture (lightly trimmed). Windows has no API for "get the selected text from another app", so it does what a person would: press Ctrl+C, read the clipboard, then put your old clipboard back.
pub fn run(app: AppHandle) {
thread::spawn(move || {
let clipboard = app.clipboard();
let previous = clipboard.read_text().ok();
// Clear first so an unchanged clipboard can't be mistaken for a fresh copy.
let _ = clipboard.write_text(String::new());
wait_for_modifiers_released();
send_copy(); // a synthetic Ctrl+C through the Win32 SendInput API
let mut captured = String::new();
for _ in 0..20 {
thread::sleep(Duration::from_millis(25));
if let Ok(text) = clipboard.read_text() {
if !text.trim().is_empty() { captured = text; break; }
}
}
if let Some(previous) = previous { let _ = clipboard.write_text(previous); }
let _ = app.emit("quick-capture", captured.trim().to_string());
});
}
// React side
listen<string>("quick-capture", ({ payload: text }) => {
if (!text) { notify("Select some text first, then press Ctrl Alt C"); return; }
// add the text to the current note
});
One gotcha: the shortcut is Ctrl+Alt+C. If you're still holding Alt when the app sends its Ctrl+C, Windows sees Ctrl+Alt+C again. So wait_for_modifiers_released() waits for Alt and Shift to come up first.
The parts a browser can't do
Three features needed Windows itself:
- Noticing the edge bump, so notes slide out when the mouse hits the screen edge
- Click-through, so when only the thin rail is showing, clicks pass through the rest of the window to the app behind it
- Grabbing selected text from any app for the Ctrl+Alt+C shortcut
All three live in a small Rust core. The rest of the app is plain React.
I didn't know Rust
Honest part: I had never written Rust. I used Claude Code. I explained what each feature needed to do, it wrote the Rust, and I tested every piece by hand.
AI is fast, but it isn't magic. Testing found bugs I would have shipped. My advice: don't let a language you don't know stop the app. Build in what you're fast in, let AI help with the rest, and test like you don't trust it.
Why the Microsoft Store
Shipping a desktop app is nothing like deploying a website. You need versions, builds, an updater, an installer, license keys and payments. And apps from unknown developers get a scary Windows SmartScreen warning.
The Store handled all of that:
- Payments: cards, taxes and local prices in every country. I set one price.
- Updates: I upload a new version and the Store updates every PC in the background. No updater to build.
- Free trial: 15 days, then a one-time purchase. It's a setting. No license server.
- Trust: signed by Microsoft, installs in one click, no warning, no yearly code-signing certificate.
The cost is a 15% cut, only when someone buys. For a solo dev, that's an easy trade.
First month numbers
- 178 store page views
- 46 installs (25.8% conversion)
- 496 sessions
- ~36% DAD/MAD, so people who keep it open it a few times a week
Small numbers, but people come back, and that was the thing I was worried about.
Try it
HideNStick Notes is $4.99 with a 15-day free trial: https://hidenstick.codeaprogram.dev
If you've shipped a Tauri app on Windows, I'd love to hear what you ran into. And if you're a web dev thinking about desktop, ask me anything in the comments.
Top comments (4)
Useful write-up. The Alt still held, so Windows sees Ctrl+Alt+C again gotcha is the kind of thing that takes an hour to find. I am moving IHatePDF from Electron to Tauri too, and on my laptop the Electron app took 1,193 ms to start and used 408 MB. Did you measure your app's start-up time or memory, or only the 3 MB installer?
Thanks! I measured memory but not start-up time yet.
Release build, idle in the tray with the window hidden, with all the WebView2 processes added up:
The app's own exe is only about 14 MB. The rest is WebView2, mostly its GPU process.
The fix: set WebView2's memory target to Low while the window is hidden (
SetMemoryUsageTargetLevel), and back to Normal before you show it. It pages memory out rather than freeing it, so RAM use drops but private bytes don't.Tip for a PDF app: WebView2 decodes images at full size, even when they're drawn small. One big screenshot used about 156 MB as a tiny thumbnail. Making small thumbnail files fixed it.
When you compare with your 408 MB, use the same counter added up across all processes.
That 156 MB thumbnail caught my eye. When you switched to smaller files, did you keep a 2× version for high-DPI screens, or was one thumbnail size enough?
One size was enough. That screenshot was in my other app, CopyNHoard, a clipboard manager that shows copied pictures in a list and a preview card. I made the small copy 2× from the start: the short side is 480 px, which covers the biggest place it's shown at 2×. The list uses the same file, and only the full preview loads the original.
The 156 MB screenshot now decodes to about 4.4 MB, so a separate 1× file wasn't worth it.