However I did lean back on AI coding a lot more with my latest project - Pexand. I wanted to try how much can I like the core desktop app building experience that I have not delved into for sometime.

Pexand a text expander. It’s written in Rust. And it’s gloriously, unapologetically “dumb.”

The “Sentinel” is Watching

Most modern apps want to know your location, your mother’s maiden name, and your favorite flavor of cloud storage. Pexand just wants to know if you typed ;shrug.

The app just monitors key strokes and upon finding a pattern replaces the abbreviation with an expanded form. While the core design suggestions were by multiple AI agents, I did try to make the app blow up here and there.

The way it works is interesting -

1. A background thread called the Sentinel sits in the background, quietly monitoring your keystrokes using Windows hooks, waiting for a trigger.
2. When the sentinel sees one, it reaches into a Radix Trie (because O(m) lookup is the only way to live) and swaps your shortcut for the real deal in under 5ms.

And.. that’s it.

Here’s what it looks like.

Why build another text expander?

• Cloud Fatigue: I don’t want my snippets synced to a server in Singapore. I want them in a local SQLite database that I own.
• The “Dumb” Factor: No AI. No “smart” suggestions. No collaboration features. Just: I type ;addr, it gives me my address.
• Rust: Honestly? I just wanted to see if I could make a GUI app in Rust without losing my mind.

The Tech Stack

Building a native Windows app in 2026 feels like a superpower with AI coding.

• Iced: The GUI framework uses the Elm Architecture, which means state management did not actually make sense to me. But, something new for sure - no more “is this component re-rendering because of a ghost prop?”
• SQLite: Every snippet lives in a local .db file. It’s ACID compliant, fast, and portable. If I want to move my snippets, I just move the file. I could also export / import snippets - just saying.
• Radix Trie: This was most unfamiliar to me. Instead of looping through a list of snippets every time you press a key, the app traverses a tree. It’s fast!

I deliberately chose a tech stack that I had been putting away for sometime now. AI coding makes everything fast - even making terrible mistakes.

I was surprised and dismayed at the same time on how coding agents have evolved and helped through the process. That’s a story for another day.

Features for the Minimalist

• Dynamic Variables: Use {{date}} or {{clipboard}} to inject context on the fly.
• App Filtering: Want expansion in VS Code but not in your terminal? Just blacklist it.
• Fuzzy Search: The “Dashboard” (summoned with Ctrl+Alt+Shift+P) lets you find snippets even if you only remember half the trigger.

Conclusion

Pexand isn’t going to change the world. It’s not a “platform.” It’s a tool.

It’s for the people who still appreciate a single .exe that does one thing and one thing.. uh, better than average. Or, it’s only for me, because I’m tired of copying and pasting from Notepad++ every time.

Check out the code, or download the binary and start being efficiently lazy: https://github.com/techformist/pexand

Just kidding - the app is far more dumb.

Notocan: A Dumb Google Keep Alternative

Notocan is what I like to say “deliberately dumb”, local and fast. It’s not trying to be the next big productivity platform with AI features, cloud sync complexity, or fancy collaboration tools. It’s just notes, done right in a browser window.

tldr;

• Has it been done a million times? Yes.
• Has it been done by me in the past? Probably, yes.
• Will it deter me from building something dumb again. Absolutely not.

The core features are straightforward:

• Create notes with titles and rich text content
• Color-code your notes for visual organization
• Pin important notes to keep them at the top
• Archive notes you don’t need anymore
• Search through all your notes instantly
• Keyboard navigation

Check it out here: https://notocan.techformist.com

If you are gungho about todo’s and notes - Notocan is open source and available on GitHub.

Feel free to use the app, or just poke around the code!

Back to the Experience

The experience though has been nothing short of refreshing. No more complex configurations, no more wrestling with SSR setups and errors, just pure Vue 3 with the Composition API.

The dev experience is incredibly fast - hot reload is instantaneous, compilation is lightning-quick, and the build process feels almost instantaneous.

It’s amazing how much mental overhead you shed when you don’t have to think about server-side rendering for a client-side notes app. Also, there are no accounts, no subscriptions, no worrying about data privacy or service outages.

Your notes live in your browser’s IndexedDB, which means:

• Instant loading (no network calls)
• Works offline perfectly
• Your data stays yours
• Migration from localStorage is handled automatically

The IndexedDB implementation includes pagination for performance, so even with hundreds of notes, the app stays snappy.

Also, I can’t say enough good things about DaisyUI. Every time I use it, I’m reminded why it was my go-to UI library. The component system is thoughtful and the default styles just work without being overwhelming.

Combined with Tailwind CSS, DaisyUI makes building polished interfaces feel effortless. The color system, spacing, and component variants work together seamlessly. It’s the kind of library that gets out of your way and lets you focus on building features, not fighting CSS. And, not having all the code in my repo mocking my design skills. I would like that mocking to be deep insite the node_modules thank you very much.

Conclusion

Building Notocan reinforced some important lessons:

1. Simple is indeed beautiful
2. I continue to be undeterred by no one using the applications I build

If you need a simple notes app, check out Notocan - it might just become your new favorite way to jot down thoughts.

TimeMomo is designed for presenters, streamers, and event managers who need to share timers with audiences in real-time, without the complexity of traditional WebSocket implementations.

What is TimeMomo?

TimeMomo is a collaborative timer application that allows users to create “rooms” where timers can be started, paused, and synchronized across all participants in real-time. Think of it as a professional timer platform for:

• Presenters who need to manage speaking time during conferences
• Streamers who want to share countdowns with their audience
• Event managers coordinating multiple sessions
• Meeting facilitators keeping discussions on track

The app features a clean, intuitive interface with room management, user authentication, and responsive design that works seamlessly on both desktop and mobile devices.

Using TimeMomo is simple.

Register > Create a room > Share the room URL with audience and presenters to see a common timer.

It is an alternative to apps like stagetimer.io, but let’s face it - there are many great apps and it’s not a great alternative. TimeMomo happens to be the app I built.

Use it for free (well, limited to 3 concurrent rooms and ~100 participants). http://timemomo.techformist.com/

Or, make the project your own! TimeMomo is open source and available on GitHub.

Try it out and let me know what you think!

Why I Built This

My motivation was twofold: learning and solving a real problem. Despite my reservations about React (I’ve always preferred Vue/Nuxt), I wanted to challenge myself with Next.js to understand what all the hype was about. At the same time, I kept encountering situations where I needed a reliable timer that could be shared across devices without the hassle of screen sharing or manual coordination.

The idea crystallized when I realized how many professional settings could benefit from a real-time timer platform - from agile ceremonies to public speaking events. And since I’m a big fan of keeping things simple, I wanted to build something that didn’t require complex infrastructure.

Technology Choices: Keeping It Simple and Powerful

Next.js: Facing My React Fears

Choosing Next.js was a deliberate step outside my comfort zone. As someone who’s struggled with React’s verbosity and component lifecycle complexities, I approached this with skepticism. However, Next.js 15’s improvements, combined with TypeScript, made the experience surprisingly smooth. The App Router and server components felt more intuitive than I expected, and the built-in optimization features handled performance concerns automatically.

PocketBase: Real-Time Magic

This is where the project really shines. PocketBase is absolutely incredible for real-time applications. While I always appreciated the one-file philosophy for entire backend, I was blown away by how it handles live synchronization without needing to set up WebSocket servers or manage connection states. The real-time subscriptions API is so clean and reliable that I could focus on building features rather than infrastructure.

The decision to use PocketBase instead of traditional WebSockets was a game-changer. It simplified the architecture dramatically:

• No need for separate WebSocket servers
• Built-in authentication and authorization
• SQLite backend that’s easy to deploy
• Automatic real-time updates across all connected clients

Shadcn/UI: The UI I Always Wanted

If PocketBase is the backend hero, Shadcn is definitely the frontend star. The developer experience is exceptional - copy-paste components that just work, with full TypeScript support and excellent documentation.

Dokploy: Deployment Adventures

Using Dokploy for the first time was an interesting experience. I always wanted the Vercel / Netlify experience at budget and this is certainly it. The ability to deploy both the Next.js frontend and PocketBase backend as containers with automated CI/CD made the whole process much smoother than traditional hosting setups.

Travails and Turbulences: The Learning Curve

Building TimeMomo wasn’t without its challenges. As someone new to React/Next.js, I hit several roadblocks:

React Learning Pains

• Understanding React’s component lifecycle and hooks took time
• State management across real-time updates required careful planning
• TypeScript integration had a learning curve, especially with complex types

I am still not a fan.

Real-Time Synchronization Headaches

• Love the real-time capabilities
• Debugging hooks - not so much

Deployment Drama

• Dokploy’s initial setup was trickier than expected
• Docker networking between Next.js and PocketBase containers

And finally.. addressing the AI in the room

AI tools were incredibly helpful throughout this project. I started out with Bolt, and switched to VSCode. Throughout the cycle, AI assistance was a game-changer for Next.js and Shadcn specifically. I was never very successful getting clean first versions out with Nuxt in the past, but with React I could certainly iterate much faster.

• Fast conversion of design ideas into working React components
• Query issues during development
• Get contextual answers for deployment issues

In Conclusion

This project taught me that sometimes stepping outside your comfort zone pays off. While I’m still not a React convert, I now understand its strengths and can appreciate why it’s so popular. The combination of Next.js + PocketBase + Shadcn proved to be incredibly productive.

Looking ahead, I’m excited about the potential improvements:

• Nuxt 4 with Nuxt UI and Shadcn-Vue MCP (that AI-assisted Vue development I keep hearing about)
• Laravel with Laravel Boost!

My plans for this app? Well, not much - unless I see people really interested.