Independent Products
The complete case study
Independent Products
Product design and software development for practical use
I design and develop applications around needs in my work and home. I define the task, structure the information, design the interface, implement its behavior, connect the relevant data, and continue improving the software through use.
This collection brings 16 featured products into one account of that ownership. The applications work with actual market information, files, recordings, account information, website signals, device activity, and system readings. Each has a purpose that connects the information it handles to something I need to understand or do.
The work spans UX, visual design, data visualization, application development, and software engineering. The deeper stories examine decisions about recording, remote control, delivery feedback, information structure, and product scope. The wider collection shows how I apply that responsibility to different kinds of problems.
Role: Product Designer and Design Engineer
Ownership: Product direction, UX and visual design, application development, integration, debugging, and functional testing
Period: March 2024 to present
Collection: 16 featured product entries across five categories
Context: Independent applications built for use in my own work and home, with continued development and refinement
PC Health and Mac Health appear together as one PC / Mac Health family. Secure is the camera-system foundation within the AEGIS story.
The situation
Software shaped by problems I needed to solve
The collection began with situations that required a useful response. A vehicle break-in in my household led me to build Secure. A Bluetooth keyboard failure led to TypeBridge. Reviewing project media and preparing image and video files led to Visual Image Browser and Forge. The computers I use to design and develop created a need for system-health visibility and hardware controls.
Each starting point gave the product a specific task. I needed to watch an area, retrieve a recording, type on another computer, find the right project assets, prepare a file, or understand what was happening inside a machine. Those needs shaped both the experience and the development work.
My professional practice already connected product direction, experience design, visual systems, and implementation. Independent development expanded the part of that work I could own directly. I could define a product, build it, use it in the environment that created the need, and return to its design when the behavior required improvement.
The collection now includes focused utilities and broader systems. Their relationship comes from the problems they address. Secure grows into AEGIS; TypeBridge and DeskBridge serve different scopes of remote interaction; Home AdBlocker Browser and AdHomeBlocker address browsing and household privacy at different levels.
The challenge
Connect a clear experience to real behavior
The central challenge was to make the interface, data, controls, and application behavior work together around a specific task. Someone needed to understand what they could do, what the software was doing, and what result to expect.
A recording button affects a session and a file. A remote-control action begins on one device and takes effect on another. A chart represents information gathered elsewhere. A hardware control changes the state of a machine. Designing those interactions required me to understand the consequences behind the visible controls and carry that understanding into implementation.
| Challenge | What I had to resolve |
|---|---|
| Scope | Define the task each product serves and the boundary between related capabilities. |
| Information | Make the source, subject, and meaning of the data understandable in context. |
| Direction | Keep the relationship between the device or application sending an action and the destination receiving it clear. |
| State | Communicate what is happening, what has completed, and what remains uncertain. |
| Consequence | Align control labels and interaction choices with the behavior they initiate. |
| Continued use | Revisit the experience when actual behavior exposes a gap in the workflow or implementation. |
These concerns gave the work a common discipline while allowing each application to have its own purpose and implementation. A focused media utility and a home-control system need different structures, even when both require clear inputs, controls, and results.
My scope and ownership
Responsibility from product definition through implementation
I own the work across product definition, UX, visual design, application development, integration, and validation. I identify the task, organize the information, design the controls, work directly in the codebase, and test how the application behaves.
I connect each application to the information, files, devices, or services its task requires. When something fails, I investigate the behavior, revise the implementation, and check how the application communicates the result.
| Area | My contribution |
|---|---|
| Product direction | Define the need, intended task, scope, priorities, and product boundaries. |
| Information architecture | Organize navigation, content, device context, controls, and relationships between tasks. |
| Interaction design | Define actions, system states, feedback, and the next step when a result is uncertain. |
| Visual design | Create product identity, hierarchy, composition, interface styling, and the presentation of complex information. |
| Data visualization | Connect the information being presented to the question a person is trying to answer. |
| Application development | Implement and revise behavior directly in the application codebase. |
| Data and systems integration | Work with APIs, local data, files, system readings, networking, and device capabilities as the product requires. |
| Testing and debugging | Exercise workflows, investigate failures, review the resulting behavior, and refine the implementation. |
| Ongoing product work | Reassess scope and improve the application as requirements and use change. |
I work in Xcode and VS Code, with technologies selected for each application. My process includes AI assistance alongside direct code review, modification, integration, debugging, and functional testing. I remain responsible for the product decisions and the resulting behavior.
The collection includes native application work and selected projects using React, TypeScript, Electron, and Vite. The engineering work varies by product: remote interaction, media processing, live data, local persistence, device access, or system controls. The shared foundation is my approach to ownership and decision-making.
The product collection
Design and technical intelligence
These products support creating, understanding, and evaluating digital experiences.
| Product | Purpose |
|---|---|
| GridLoom | A workspace for design and development work. |
| StackLens | Website technology inspection and analysis of publicly observable signals. |
| Principle Atlas | A knowledge application for working with design-system information. |
Devices and system control
These applications connect an interface to another computer, a mobile device, or the condition and controls of a machine.
| Product | Purpose |
|---|---|
| DeskBridge | Remote computer control between Mac and PC, with file transfer, iPhone access, and use outside the home. |
| TypeBridge | Typing and control input from an iPhone to PC or Mac, and from Mac to PC. |
| MobileDock | Mobile-device and file access for development and investigation. |
| NovaCore Command | PC management and customization across RGB, memory, health, fan speed, themes, and related controls. |
| PC / Mac Health | System-health visibility across the machines I use for design and development. |
Media and creative workflows
These products address accessing media, reviewing project material, and preparing files for use.
| Product | Purpose |
|---|---|
| LumaStream | A unified streaming and media hub. |
| Visual Image Browser | Locating and reviewing images, GIFs, and videos from selected project folders. |
| Forge | Reducing image and video file sizes through a focused processing workflow. |
Finance and personal data
These applications make market and personal account information useful within a defined task.
| Product | Purpose |
|---|---|
| TradeCalc Pro | A trading calculator connected to live market information. |
| CreditPulse | Access to my credit platforms, captured account information, and data visualization in one application. |
Security and privacy
These products address monitoring, home-system access, browsing, and advertising activity across devices.
| Product | Purpose |
|---|---|
| AEGIS | A smart-home application incorporating Secure cameras and recording, invited accounts, roles, weather, service availability, and access integrations. |
| Home AdBlocker Browser | Browsing and search with privacy controls and organization around my activities. |
| AdHomeBlocker | Household ad blocking with visibility into advertising activity and devices. |
Connecting purpose to data and controls
Start with the task and its consequences
I use the relationship between purpose, information, action, and result to evaluate a product. It gives me a way to move between UX decisions and implementation without losing sight of what the application is meant to accomplish.
| Dimension | The decision it supports |
|---|---|
| Purpose | Why the product exists and which need defines its scope. |
| Task | What the person is trying to accomplish and what completion means. |
| Data | Which information, files, device state, or activity the task depends on. |
| Control | What the person can choose, initiate, adjust, stop, or manage. |
| Direction | Where information or an action begins, where it goes, and what response returns. |
| Result | How the person understands the outcome and what they can do next. |
The relationship is different in each application. Forge connects a source file to processing and resulting media. TypeBridge connects an input to a receiving computer. Secure connects monitoring conditions to recordings that can be found and reviewed later. CreditPulse connects account information to a visualization I can interpret.
Define boundaries before adding breadth
Related capabilities can create confusion if their tasks are unclear. I keep TypeBridge focused on directing input while DeskBridge covers the broader remote session. Home AdBlocker Browser addresses browsing and search while AdHomeBlocker covers the household environment. PC / Mac Health provides visibility into machine condition while NovaCore adds broader PC controls.
Those distinctions help me decide where a capability belongs and how someone should reach it. They also make the collection understandable as a set of purposeful products.
Use implementation behavior to refine the experience
Development reveals details that a static interface cannot settle on its own. A viewing session can stop while a camera continues its own recording. An input can arrive even when delivery is unconfirmed. A source collection can look complete while still failing to provide the guidance the product was intended to offer.
I treat those details as product decisions. They affect labels, navigation, feedback, and completion criteria, as well as the code behind them. The following examples show how I work through that relationship.
Secure and AEGIS
Turn a household security need into a working system
Secure began after a vehicle break-in in my household. I wanted a way to monitor the areas around our home, understand relevant activity, and return to recorded footage when I needed it. That starting point gave the work a clear purpose and made the relationship between observation, recording, and storage central to the product.
I owned the product definition, interface design, application development, and integration work. My responsibility included deciding what a person needed to control, organizing that information in the experience, and carrying those controls into working application behavior. The product had to support a continuing task across live monitoring, recorded material, and the devices and drives involved.
Connect detection to a useful recording workflow
I shaped the monitoring scope around specific viewing areas, motion, and distinctions among people, vehicles, plants, and trees. Day and night conditions and defined recording periods also mattered. Movement near a vehicle and movement in surrounding vegetation create different reasons to review an event, so the product needed to make the monitoring context understandable.
I connected that context to footage management. The workflow includes selecting where recordings are stored, reviewing the resulting files, and retaining or erasing footage from designated drives. Those choices carry consequences beyond the moment a camera image appears on screen.
| Part of the task | Product responsibility |
|---|---|
| Establish the monitoring scope | Make the relevant area, activity, and time window understandable. |
| Capture the period that matters | Connect monitoring conditions to recording behavior. |
| Manage the resulting footage | Support saving, viewing, and erasing recordings from the designated drives. |
The design problem spans these steps. A recording control needs to make sense in relation to what is being watched, when the recording should occur, and where the result can be found. I use those relationships to organize the experience and evaluate whether the application is serving the original need.
Give similar controls distinct consequences
One concrete decision in Secure’s November 1, 2026 implementation was to distinguish stopping a viewing session, closing the main window, and quitting the application.
Stop Watching ends the selected viewing session and finishes its local recording file. Closing the main window can leave the application operating. Quitting during a recording asks first and finishes the recording files. The camera’s own SD recording remains independent of the application’s viewing session.
These distinctions connect interaction design to application lifecycle behavior. A person who closes a window may have a different intention from someone who ends a viewing session or quits the application. The implementation needs to preserve those meanings, particularly when recorded material is involved.
This is the kind of detail I carry across design and development: define the scope of an action, make its meaning understandable, and account for the resulting state of the application and its files.
Expand the foundation into AEGIS
AEGIS brings the camera and recording system into a broader smart-home experience. I expanded the scope to include invitation-only accounts, account setup, Standard, Main, and Admin roles, weather information, web-service downtime detection, Tailscale integration, HTTPS access, and agents that support continued application operation.
The expansion introduces different kinds of information. A camera event, an account role, and an unavailable web service each call for a different response. My design responsibility is to give those capabilities a clear place in the experience while keeping their individual tasks understandable.
The account workflow begins with an invitation, followed by the invited person creating and setting up their account. The interface must communicate the account context alongside the capabilities available within the system. In development, that means connecting the experience to the account and access behavior behind it.
Practical value and ownership
Secure gives me a way to observe relevant activity and manage the footage associated with it. AEGIS extends that purpose into accounts, access, environmental information, service conditions, and continued operation.
The work demonstrates how I grow a product from a specific need while remaining responsible for its scope, interface, data, and behavior. As the system expands, I keep returning to the task each capability serves and the action it enables someone to take.
Extend the system’s everyday context
I extended AEGIS beyond camera views to include weather and service monitoring. Weather moves from a current estimate to hourly and daily context, with source attribution and timing beside the reading. Service monitoring brings exceptions forward, keeps frequently checked providers together, and shows when their status was last read.
Each view gives the information its own structure while keeping the source, time, and next useful action visible. The visual case study uses demo home imagery, a San Francisco demo location, and example pinned services to keep personal details private.
View the AEGIS home overview, weather, and service monitoring
TypeBridge
Restore input when a physical keyboard fails
TypeBridge began when my Bluetooth keyboard stopped functioning. I needed another way to use my computers with the devices already available to me. That immediate need defined a focused product: send typing and control input from an iPhone to a PC or Mac, and from a Mac to a PC.
I owned the input experience, destination selection, interface design, and application development. The interaction begins on one device and produces its result on another, so the target and direction of control are part of the experience itself.
Keep the receiving computer clear
The central workflow is to choose the intended computer, enter input, send it, and understand what happened. A person needs to know which machine is receiving the action while continuing to work on the device in hand.
That relationship shapes the interface and the implementation. Target selection, input, connection state, and delivery feedback need to describe the same task. A clear keyboard layout is one part of the work; the surrounding experience explains where its actions go.
I use the supported device paths to define the product’s scope: iPhone to PC, iPhone to Mac, and Mac to PC. This gives the interaction a concrete destination instead of leaving device control as an abstract capability.
Give typing, pointer control, and sharing focused workspaces
The Type, Mouse, and Share views keep the selected computer in a consistent position above the task. Destination-specific labels such as “Send to Windows” and “Paste image on Windows” repeat that context at the point of action.
For pointer control, I paired the touch trackpad with visible click, drag, and scroll controls and an adjustable pointer speed. For sharing, content selection and sending are separate steps. These choices give each task a clear interaction while preserving the direction of control between devices.
View the Type, Mouse, and Share application screens
Make uncertainty actionable
A delivery problem reveals an important design decision. TypeBridge’s recovery screen explains that an action may have arrived and that nothing resends automatically. It provides a way to check the last delivery and confirm that the target computer has been checked.
The design makes uncertainty explicit before a person attempts another action. A delayed or unconfirmed result can create a different problem from a confirmed failure: repeating an input could duplicate something that already reached its destination.
That extra check adds a step to the recovery experience. Its purpose is to help the person establish what happened before continuing. The interface connects the uncertain state to a practical next action instead of leaving the person to interpret an error alone.
Practical value and ownership
TypeBridge gives me another input path when a physical keyboard is unavailable. Its scope connects a real hardware problem to software I can use across my devices.
The work brings together keyboard interaction, device context, application communication, and recovery feedback. My responsibility extends across those parts so that the action presented on one screen remains understandable in relation to its result on another.
DeskBridge
Operate a computer from another device
DeskBridge addresses the broader task of operating a remote computer. I built it around Mac-to-PC and PC-to-Mac control, including viewing, typing, interaction, and file transfer. I also created an iOS application in Xcode so I could access those computer workflows from an iPhone.
The product supports access outside the home through Tailscale and other access integrations. That extends its purpose beyond moving between computers in the same room: the experience needs to remain understandable when the computer and the person controlling it are in different locations.
My ownership spans the product scope, desktop and mobile experiences, interface structure, application development, device communication, and file workflows. The task is complete when the person can reach the intended computer and perform the work they connected to do.
Organize the session around distinct tasks
I separate Devices, Sessions, Transfers, and Security in the interface. Saved connections and trusted-device status provide context around those areas.
This structure gives each part of remote work a clear purpose. Devices identifies the machines involved. Sessions organizes the active connection. Transfers gives file movement its own place. Security holds the access-related context. These distinctions help the person understand whether they are choosing a computer, operating it, moving files, or reviewing access.
The separation also shapes the development work. Each interface area needs to correspond to the behavior it represents, and changes in one part of a session need to remain understandable in the others. The application’s structure has to support the task as it moves from connection management into active work.
Make the connection state part of the working interface
The desktop workspace brings saved-host information, the selected computer, connection status, and a Connect action together. The portfolio view uses Asus and Mac as example saved hosts, with Asus shown in the source capture’s disconnected state. The saved computer remains visible while the interface makes clear that an active session has not started.
I separate configurable session controls from measured stream details. Clipboard sync, remote input, and reconnect have their own controls; resolution, bitrate, packet loss, and codec belong to a separate information group. When a stream is unavailable, those measurements remain empty rather than implying an active session.
The compact rail and expanded sidebar preserve the same task structure at different densities. Saved connections and pairing status stay close to Devices, Sessions, Transfers, and Security, keeping access context within the workspace.
View the desktop workspace, navigation, and controls
Carry the same intent across desktop and phone
The controller and destination are different parts of the same interaction. The person acts on one device while the resulting change occurs on another. DeskBridge therefore needs to preserve the identity of the destination throughout the session.
An iPhone adds different constraints from a desktop controller, including screen space and touch input. I treat the mobile experience as part of the remote-control task: choose the computer, see the relevant context, and perform the intended action from the phone.
This connects UX decisions directly to implementation. The interface must make the session understandable while the application carries input and file operations to the destination. Visual hierarchy, navigation, and technical behavior all contribute to completing the same task.
Connect local and outside-home use
Tailscale is part of the configured access setup for using DeskBridge away from home. Its role in the product is to support where a remote session can take place. The person still needs a clear account of the selected computer and the session they are operating.
I keep the distinction between access and interaction clear: reaching a computer establishes the connection, while the product experience supports the work performed through it.
Practical value and product boundaries
DeskBridge enables remote computer work across my desktop and mobile devices, including moving files needed for that work. TypeBridge serves the narrower need to direct input to another device; DeskBridge supports the broader remote session.
That boundary is a product decision. It gives each application a clear task while allowing both to grow from related needs. Together, they show my ownership of interface design, software behavior, and the movement of information and actions across devices.
StackLens
Turn website signals into an understandable assessment
StackLens examines website technology and publicly observable signals. I designed and developed it to make that information easier to inspect, interpret, and act on. The product works from a site URL and organizes the results into views with different responsibilities.
An inspection of my own website makes the structure concrete. Anatomy presents site structure, theme and visual information, layout analysis, duplicate signals, and improvement items. Analyst presents strengths, concerns, research angles, and an action plan.
Separate observation from interpretation
I gave inspection and interpretation distinct places in the experience. A person can examine what the application observed, then review the assessment and proposed next steps. This organization makes the role of each view clear.
The separation introduces a transition between studying a finding and acting on its interpretation. The benefit is a clearer distinction between the underlying signal, the meaning assigned to it, and the action being suggested. The interface gives those different kinds of information different jobs.
My ownership includes the taxonomy of findings, navigation between views, visual hierarchy, application behavior, and the relationship between collected information and presented analysis. The data work and the interface structure serve the same task: understand a site well enough to decide what deserves attention.
Keep the scope of the inspection visible
StackLens identifies the public signals it examines, including headers, DNS, TLS, HTML, scripts, SEO, privacy, and security-related information. This sets the context for interpreting a finding.
For example, an observation about a security header can lead to an action to review that header. A missing image description can lead to a content or accessibility improvement. The recommendation remains connected to something the application observed.
That relationship is part of the product's credibility. I keep the meaning of a result within the scope of the information available to the application.
Practical value and ownership
StackLens gives me an organized way to examine a website and review potential improvements. It brings data collection, information architecture, interpretation, and visual communication into one product experience.
The work shows how I connect technical information to a useful decision. The interface makes the subject navigable, while the implementation supplies the observations and resulting views that make the task possible.
Principle Atlas
Correct the gap between a working application and its intended purpose
Principle Atlas addresses design-system knowledge. An early implementation collected sources and presented summaries, but the experience did not yet provide the structured guidance I wanted to use in design and development work.
I identified a product-definition problem: the existing organization emphasized the material being collected, while the intended task required guidance that a person could browse, compare, understand, and apply. I revised the direction around that task.
Change the structure and the completion criteria
The revision centered on how guidance should be organized and connected to its source. A useful item needs enough context to explain what it means, where it applies, and what supports it. That requirement affects the content model, navigation, and how the information is presented.
I also changed how I defined completion. I treated a successful build or packaged application as one development checkpoint. Completion also depended on whether the launched application delivered useful guidance within the task it was meant to support.
This example covers a direction and acceptance decision at that development checkpoint. I defined more structured guidance and reuse as requirements for the revision. The decision was to bring the implementation closer to the product's purpose before treating the experience as complete.
Connect guidance to its source and review context
The Systems view brings a selected design system, categories, source links, change indicators, and coverage information into one workspace. Those relationships give the collected material a structure that supports browsing and review.
The interface keeps the official source close to the guidance and gives coverage and change information their own place. Coverage and change indicators give source review a visible place in the experience.
View the Principle Atlas application screen
Ownership of the product standard
My responsibility included recognizing the mismatch, clarifying the task, and translating that clarification into requirements for the application. I connected information architecture to the behavior and output the product needed to support.
Principle Atlas makes an important part of my practice visible: I evaluate software against the work it is supposed to help someone do. When the current implementation falls short of that purpose, I revise the product direction and the criteria for the next iteration.
Additional product workflows
Design and technical intelligence
GridLoom
GridLoom is the design and development workspace within this collection. I own its product direction, information architecture, interface design, and application development. Its focus is supporting the work of shaping and developing digital products.
Media and creative workflows
LumaStream
LumaStream is a unified streaming and media hub I designed and developed. Its purpose is to bring media access into a coherent experience.
The product connects information architecture, visual design, and application development. I approach its organization around the relationship between a media collection and the content someone wants to reach. That gives the interface a concrete purpose and keeps the development work connected to the experience the product is intended to provide.
Visual Image Browser
Visual Image Browser grew from reviewing material during my projects. Images, GIFs, and videos already existed in project folders, but I wanted a focused way to locate and display the material relevant to the work in front of me.
I designed and developed the application around selecting specific folders and reviewing their media. Keeping the folder context central connects what I am seeing to the project I am evaluating. The task has a defined beginning and result: choose the relevant source, find the material, and review it.
This gives the visual organization a practical role. The interface supports finding and examining actual project assets, while the implementation connects those views to the selected files. I use it as part of the review work that informs my design decisions.
Forge
Forge began with a recurring production task: reducing the size of images and videos I create. I wanted direct control over that operation in my own application, without repeatedly moving the task to a third-party service or opening Premiere Pro.
I kept the product focused on the relationship between a source file, the controls used to process it, and the resulting media. That boundary shaped both the interface and the development work. Each step needs to make the operation understandable so I can prepare a file for its next use.
My ownership includes the workflow, visual design, application behavior, and processing integration. Forge carries a specific piece of my creative workflow into working software: take media I have produced and reduce its size under my own control.
Finance and personal data
TradeCalc Pro
TradeCalc Pro connects a trading calculator with live market information. I designed and developed it around the relationship between the information being observed, the values used in a calculation, and the result someone needs to understand.
This requires clarity at several levels. Market information provides context, calculation inputs express the scenario, and the resulting values need a clear place in the interface. My work connects those roles through information structure, visual design, data integration, and calculation behavior.
The useful output is an understandable calculation grounded in the selected inputs and market context. My responsibility extends from organizing that information in the interface to implementing the behavior that produces the result.
CreditPulse
CreditPulse grew from my ongoing effort to understand and improve my credit. I wanted one application where I could access my platforms, sign in, capture the relevant information, and review it through data visualization.
I designed the experience around the movement from account access to captured information and then to a view I can interpret. That sequence gives the charts a defined purpose: help me make sense of information from my own accounts.
My work includes the product structure, interface, application development, and the connection between captured data and its presentation. I use CreditPulse to review my credit information in a consolidated experience. Improving my score remains the personal goal behind the product; the software's role is to make the information accessible and understandable.
Security and privacy
Home AdBlocker Browser
Home AdBlocker Browser addresses my browsing and search experience. I wanted more control over advertising, tracking, and clutter, with useful content organized around the task I was trying to complete.
Classic Google-style search informed the direction: results centered on the search itself, with less sponsored material interrupting the experience. I also organized the product around my own needs, including design, development, and streaming.
My ownership connects those product decisions to the interface and application behavior. Privacy controls and information architecture belong together here because both affect how I reach relevant content. Home AdBlocker Browser gives that work a defined scope within browsing and search, distinct from the household-wide system in AdHomeBlocker.
AdHomeBlocker
AdHomeBlocker extends my privacy work across the devices in my home. I wanted visibility into advertising activity and connected devices, together with controls for managing ad blocking across that environment.
I designed and developed the product around the relationship between activity, its presentation, and the action available to me. Data visualization has a specific responsibility: help me understand what the system is observing so I can use the controls in context.
This work includes both the application experience and the supporting system infrastructure. I continue reviewing and upgrading it as my requirements change. Its household scope gives it a separate purpose from Home AdBlocker Browser, which centers on the browsing and search experience.
Devices and system control
MobileDock
MobileDock supports the development work I do with mobile devices. I wanted access to devices and their accessible files so I could investigate application behavior with a clearer understanding of the environment in which it runs.
I designed and developed the experience around that relationship: a device provides context, its available files provide material to inspect, and the investigation serves a development task. The interface needs to keep those connections understandable as I work.
MobileDock is therefore part of my development workflow itself. Its purpose is to help me examine the device context and continue building with a more concrete understanding of how mobile applications operate. The scope follows the access available on the supported device.
PC / Mac Health
PC Health and Mac Health grew from the computers I depend on for design and development. I need to understand their condition and use that information when deciding whether maintenance, an upgrade, or a replacement deserves attention.
I designed and developed these applications to make system readings useful in the context of the work I expect each machine to support. The interface organizes the information so I can review the machine's condition, while the implementation connects that presentation to actual system data.
They address the same need across two operating environments, so I present them as one PC / Mac Health family. Their contribution is visibility into the machines I use, giving me information to consider when planning how to maintain or improve my working setup.
NovaCore Command
NovaCore Command brings PC management and customization into one application. Its scope spans RGB, memory, system health, fan speed, themes, and related controls.
I designed and developed it around a distinction that affects the whole experience: reviewing the state of a system and changing its behavior are different tasks. The interface needs to make the part of the PC I am working with and the available action understandable. That relationship connects the information architecture to the underlying control behavior.
NovaCore gives me a broader way to manage and personalize my PC. Within the collection, PC / Mac Health supports understanding machine condition, while NovaCore adds a wider set of management and customization controls. Each product has a defined role in how I work with my systems.
Real data and implemented workflows
Give information a role in the task
The collection works with different forms of actual information. Some applications use live market data or system readings. Others work with local files, captured account information, recordings, website signals, or collected source material. I choose the information and integrations around the task each product serves.
The following map keeps every featured product connected to its input and purpose. Principle Atlas includes its current source-review task and the structured-guidance revision described above.
| Product | Information or input | Task or result |
|---|---|---|
| GridLoom | Design and development material within its workspace. | Support work on digital products and interfaces. |
| StackLens | A site URL and publicly observable website signals. | Inspect the site, review findings, and assess suggested actions. |
| Principle Atlas | Collected design-system sources and summaries. | Review collected design-system sources and summaries. |
| DeskBridge | Destination computer state, input, and files. | Operate a remote session and move files between devices. |
| TypeBridge | Typing or control input, destination identity, and delivery feedback. | Direct input to the selected computer and understand its reported state. |
| MobileDock | A supported mobile device and accessible files. | Examine device context during application development. |
| NovaCore Command | PC readings, configuration, and available hardware controls. | Manage and personalize the supported PC functions. |
| PC / Mac Health | System readings from Mac and PC. | Review machine condition and inform maintenance or upgrade decisions. |
| LumaStream | Media and streaming information within the hub. | Access media through an organized experience. |
| Visual Image Browser | Images, GIFs, and videos in selected project folders. | Locate and review material in its project context. |
| Forge | Image or video files and size-reduction controls. | Process media and use the resulting file. |
| TradeCalc Pro | Live market information and calculation inputs. | Produce and interpret a trading calculation. |
| CreditPulse | Information captured from my signed-in credit platforms. | Review account information through consolidated visualizations. |
| AEGIS including Secure | Camera activity, recording windows, footage, drives, accounts, weather, and service state. | Monitor, record, review, and manage the relevant home-system tasks. |
| Home AdBlocker Browser | Browsing content, search activity, and privacy controls. | Reach useful content with more control over advertising and tracking. |
| AdHomeBlocker | Household device and advertising activity. | Understand activity and manage ad blocking across devices. |
Carry the relationship into the application
Implementing these tasks involves connecting the interface to the behavior behind it. Depending on the product, I work with data access, local persistence, networking, media processing, system information, or device controls. I review and modify the code, investigate failures, and test the resulting functionality.
The completion question remains specific. A media operation needs a resulting file. A remote action needs a clear destination and response. A recording needs a location from which it can be reviewed. A visualization needs an understandable relationship to the information it represents.
Those questions give the technical work a product standard. They also keep the visual experience connected to the actual task.
Visual design and data visualization
Make the structure visible
Visual design is part of how I make each product understandable. It includes identity and composition, along with the hierarchy that tells someone where they are, what matters, and what they can do next.
In DeskBridge, the separation of devices, sessions, transfers, and security gives remote work a visible structure. In StackLens, the Anatomy and Analyst views distinguish inspection from interpretation. Visual Image Browser keeps project media connected to the folders being reviewed. The organization of each interface follows its task.
I use labels, grouping, spacing, typography, and emphasis to express those relationships. A product can have a distinct identity while maintaining a clear hierarchy of information and controls.
Connect data visualization to a useful question
CreditPulse, PC / Mac Health, NovaCore, AdHomeBlocker, and StackLens all involve making information interpretable. The subject changes, but the design responsibility remains concrete: help someone understand what the information describes and which decision it supports.
| Product context | Question the presentation supports |
|---|---|
| CreditPulse | What can I understand from the information captured across my credit platforms? |
| PC / Mac Health | What do the available readings tell me about the condition of the machine I use? |
| NovaCore Command | Which part of the PC am I reviewing, and which controls are available? |
| AdHomeBlocker | What advertising or device activity is being observed, and what can I manage? |
| StackLens | What did the inspection find, how is it interpreted, and what deserves attention? |
These questions shape the relationship between data, labels, visual grouping, and action. The appearance of a chart or panel is one part of making that relationship understandable.
Give exceptional states a clear place
TypeBridge's uncertain-delivery screen is a useful example of visual and interaction design carrying a technical condition. The message makes the uncertainty visible, and the available action gives the person a way to investigate before continuing.
The engineering concern is the state of an action across devices. The UX concern is what the person can reasonably understand and do. The visual concern is making that message and next action easy to locate. I work across those concerns as parts of the same experience.
Practical outcomes and reflection
Tools I can use for the work that created them
The result is a collection of applications that serves practical tasks in my work and home. I can connect each product's purpose to the information it handles and the action it enables.
| Need | Practical capability developed |
|---|---|
| Monitor relevant activity and return to footage. | Secure monitoring, recording, selected-drive storage, and review, extended through AEGIS. |
| Continue using a computer when a keyboard is unavailable. | TypeBridge input from another device. |
| Work on a computer from desktop or phone. | DeskBridge remote control, typing, and file transfer. |
| Review and prepare creative material. | Visual Image Browser for project media and Forge for reducing file sizes. |
| Understand the machines I depend on. | PC / Mac Health readings and NovaCore management controls. |
| Review information across a defined subject. | CreditPulse account visualization and StackLens website analysis. |
| Manage browsing and household advertising activity. | Home AdBlocker Browser and AdHomeBlocker at their respective scopes. |
These outcomes are meaningful because they connect a need to software I can operate. Continued use also gives me the next design and development problem: a state that needs clarification, a workflow that needs refinement, or a capability whose scope needs to change.
Judgment across the experience and its implementation
The deeper examples reveal different kinds of judgment. Secure requires me to preserve the meaning of controls as the system grows. TypeBridge requires a clear response to uncertainty. DeskBridge requires a coherent task across devices. StackLens requires a distinction between observation and interpretation. Principle Atlas requires the willingness to revise an implementation that does not yet serve its intended purpose.
Those decisions connect product strategy to engineering detail. I can work through the purpose of a capability, the way it appears in the interface, the information it uses, and the behavior it produces. That range helps me recognize which part of a product needs attention and carry the decision into the next iteration.
How the collection fits my broader practice
My work across AppFuzer, Nike, Zillow, and other professional settings involves product direction, experience design, visual systems, implementation, and collaboration. Independent Products adds a direct view of my personal responsibility for application development and the systems behind the interface.
Together, these bodies of work show how I connect a broader product objective to the details that make an experience usable and functional. I bring design craft, information structure, technical judgment, and hands-on development into the same conversation.
I design the experience, develop the behavior, and continue improving the product through use.
Selected implementation details remain private. I can discuss relevant product decisions and technical tradeoffs in an interview.