The Vault is a creative archiving tool built for designers, artists, and collectors who need a way to organize visual inspiration that goes beyond bookmarks and screenshots. It is a desktop application where users can save images, group them into collections, add context, and search across their entire archive in seconds. The interface is minimal by design: the work should be visible, not the chrome around it.

Built as my Parsons MFA thesis project, The Vault explores what it looks like when a tool is designed entirely around the creative process rather than around engagement metrics, social sharing, or productivity theater.

For years I collected images across five different apps, none of which talked to each other. Pinterest was too public, too algorithm-driven. Google Drive was functional but dead. Apple Notes held things together with tape. Every time I sat down to start a project, the first hour was spent hunting through old screenshots, broken links, and folders named "final final 2." The Vault came from exhaustion with that fragmentation. I wanted one place that felt like mine.

The thesis framing pushed me deeper: what does it mean to build a tool that is honest about what it is? The Vault is not a social network pretending to be a utility. It does not want your attention. It stores what you give it and returns it when you ask. That simplicity is the design.

The first version of The Vault was a Figma file. I used components, variants, and auto-layout to simulate an actual application interface. It worked well enough that I kept using it. That experience became the thesis argument: Figma is not just a prototyping tool. For designers, it is often the closest thing to a real product environment we have access to without writing code.

The irony is not lost on me. A tool for archiving visual work, built inside a design tool. But that irony is the point. The Vault started where designers actually live.

Pinterest is the most obvious competitor and the most instructive one to study. Its strength is volume: billions of images, searchable, endlessly scrollable. Its weakness is that it was never designed for the person who needs to find something specific they saved six months ago. The feed is a trap. The algorithm surfaces what is trending, not what you saved. The board system exists, but boards become cluttered quickly and offer no meaningful hierarchy beyond that top level.

More fundamentally, Pinterest is optimized for discovery and engagement, not retrieval. The Vault inverts that priority. Discovery happens outside the app. Once something is saved, The Vault's job is to make it findable, organizable, and contextual. No feed, no trending, no notifications.

Users drag images directly into The Vault from anywhere on their desktop. Images are automatically organized by date added and can be manually sorted into named collections. A tagging system allows cross-collection search, so an image can live in one collection but surface across several searches. The detail view shows the image at full resolution alongside any notes, tags, and source information the user has added.

The Figma Plugin version integrates directly into the design workflow: users can vault an asset from any Figma file without leaving the application. The plugin syncs with the desktop app, keeping the archive unified across contexts.

The early Figma versions were dense and overdesigned. I kept adding features I thought a "real" archiving tool would need: tagging systems, metadata panels, sorting controls, sharing options, until I stepped back and asked what I actually used when I opened the old Figma file. The answer was simple: I dropped things in, grouped them, and searched. Everything else was noise. The later versions are defined by what I removed.

The Figma Plugin extends The Vault directly into the design environment where most of my archiving impulse actually happens. While working on a project, you encounter references, textures, screenshots, and type specimens that belong in your archive but not necessarily in your current file. The plugin lets you send any frame or image to The Vault in one click, with the current file name and date attached automatically as metadata.

The plugin is intentionally minimal: a search field and a recent-adds list. No configuration, no settings screen, no account to manage. It does one thing. The full archive lives in the desktop app.

The Figma plugin worked, but the whole time, it felt like The Vault was living in Figma's shadow. Every interaction was scoped by what a plugin was allowed to do, and no matter how good it got, it would always read as a clever Figma add-on, not its own thing.

That didn't feel right. The Vault felt like it deserved to be bigger than a plugin, something closer to a living, breathing piece of software than a feature bolted onto someone else's tool. So I made the call to build it standalone: no plugin sandbox, no borrowed canvas, no platform ceiling. Just The Vault, on its own terms.

Once it was standalone, the next thing I ran into was scope. Just archiving images didn't feel like enough to justify calling this a piece of software. A real creative archive isn't only visual, it's audio, video, PDFs, whatever medium the actual reference lives in. Restricting The Vault to images meant asking people to leave their best material out of their own archive.

This pivot happened while I was an Artist Advocate at NY4CA (New Yorkers for Cultural Arts), where I was awarded grant funding specifically to keep developing the product. I expanded The Vault to support full multimedia: images, audio, video, and PDFs (currently macOS only), all living on the same freeform canvas.

The next problem wasn't what The Vault could hold, it was how much control to hand a user over AI-generated results, and how to make that control feel intuitive rather than like a settings menu.

Early versions auto-tagged everything a user saved: mood, color palette, descriptive tags, all at once. It was fast, but it felt like the app was making decisions for you rather than with you. Users had no way to say "tag this one thing, but leave that one alone."

I redesigned this as a selective, human-in-the-loop control: a bulk "Get Info" action where users check exactly which fields they want AI to fill in, per item, per field, leaving everything else untouched. Nothing happens without an explicit signal from the user, and every AI action is scoped, reversible, and visible before it's applied.

This ended up being the single most important interaction pattern in the product, not because it was the flashiest feature, but because it's the difference between an AI tool that feels like a collaborator and one that feels like it's guessing on your behalf.

The Vault's architecture today reflects all three pivots: it's part browser extension, part standalone software, on purpose, not by accident.

The Chrome extension is where capture happens, the moment you find something worth saving, mid-browsing, with zero friction. The desktop app is where that material actually becomes something: organized, clustered, annotated, and increasingly, understood by AI on your terms. Neither half works as well without the other, and that split is the whole point: capture has to be instant, and organizing has to be unhurried.

I designed and built The Vault entirely myself: product design, interaction design, and full-stack development, using Claude Code as a core, everyday part of the build process. This wasn't AI-assisted in the shallow sense of autocomplete; it shaped how I approached architecture decisions, debugging, and shipping cross-platform builds solo.

Stack: Electron, React, Vite, Konva, SQLite, Supabase, and the Anthropic API, packaged and shipped for both macOS and Windows.

Shipping this solo meant finding real bugs the hard way, and I think how you handle that says more about your judgment than the parts that went right the first time.

• A packaging misconfiguration once shipped raw API credentials inside the Windows build. I caught it, rotated every exposed key, and closed the gap in the build pipeline.
• An early sync implementation could let a blank field from one device silently overwrite real data on another. I redesigned the sync logic to allow healing (filling in blanks) while blocking anything that would blank out existing data.
• A crash-on-reopen bug traced back to a stale window reference; a silent startup failure traced back to a Supabase call that could throw before the window ever rendered. Both were invisible until I went looking for them specifically.

None of these were catastrophic, but each one taught me to distrust "it works on my machine" a little more and verify against the actual packaged build, not just the source.

• A freeform spatial canvas with pan/zoom, category clustering, and a grouping system that lets text and media snap together and move as one rigid unit, or detach cleanly with a single gesture.
• A multi-vault dashboard (Main Vault, Portfolio Research, and project-specific vaults), each with its own item count, sharing settings, and history.
• A real permission model: Owner, Co-owner, Editor, and Viewer roles, so a vault can be shared and collaborated on without losing control over who can do what.
• A Chrome extension with a multi-vault picker and a hover-to-save button, including a fix I shipped for a real bug where the save button collided with YouTube's in-player ad overlays.
• Signed, notarized macOS and Windows builds, packaged and distributed independently, no app store required.
• Local-first cloud sync, so a personal vault follows a user across devices without needing the app open on both ends.

The Vault was recognized at the Parsons Thesis Show for its AI-assisted interaction design, and selected for NY4CA's (New Yorkers for Cultural Arts) Artist Advocate Residency, which came with grant funding specifically to continue developing the product.

It's currently in a friends-and-network beta, with signed macOS and Windows builds, a working Chrome extension, and a Firefox extension approved on Mozilla's add-on store. My next step on feedback is shifting toward former design colleagues rather than casual testers, since rigorous, critical feedback from people who've shipped products before is worth more right now than broad but shallow usage data.

From here, the roadmap is: wider browser support (Edge next, since it shares Chrome's extension architecture; Safari after, a bigger lift), a public Chrome Web Store launch, and continuing to push the AI side of the product: further human-in-the-loop controls, deeper on-canvas intelligence, without ever making the tool feel like it's making decisions without you.