Minimize, close, and discard are different operations

Follow the user's train of thought

Business work rarely moves through a tidy sequence of pages. Someone opens a customer, checks an asset, looks at a project, and returns to the customer with an answer. During that sequence, they may also need a document or a conversation.

That is why desktop-style workspaces interest me. A well-designed shell can keep several pieces of work available and make switching between them feel deliberate. The value is continuity: the record, selection, and unfinished work are still there when the person returns.

My work on the ElementalOS and Nexus interface has made this an important design area for me. It also raises a useful question for any project: which parts of a desktop interaction model actually help this application's users?

Define the shell's responsibilities

I want the shell to manage the workspace. That includes opening and closing views, deciding which window is active, managing stacking order, and connecting minimized windows to the taskbar.

The application inside a window should own its actual work. A customer workspace owns customer selection and its editing flow. A document workspace owns the document and the editing experience. Neither should need detailed knowledge of how another window draws its title bar.

In React, I prefer to express that structure through composition. The page brings together the shell, navigation, workspace surface, and supporting panels. A window composes its frame, controls, and content. Smaller children handle focused behaviors.

This gives each piece a clear job and makes it easier to change the window frame without disturbing a customer form or editor.

Interaction details are the product

A draggable rectangle is the beginning. The experience becomes credible through its behavior under ordinary use.

What does a double-click on the title bar do? Can the user restore a minimized window without losing a draft? Does opening an already-open customer focus the existing window or create another instance? What happens when the browser becomes narrower than the current arrangement?

I want those choices to be intentional. Window identity, record identity, and temporary editing state need clear relationships. Closing a view and discarding a change should never become accidentally interchangeable operations.

Keyboard behavior matters too. A user should be able to reach window controls, understand where focus is, and return to the work after dismissing a menu. Right-click menus can make common actions convenient, with the same actions available through visible controls.

These details determine whether the interface feels dependable after the initial visual impression.

minimize(window) => ({
  ...window,
  minimized: true
})

// Normal geometry and document state remain.

Give the layout room to adapt

A desktop-style workspace needs an appropriate smaller-screen experience. On a phone, a focused view with a clear switcher may serve the task much better than shrinking several floating windows until none is readable.

I treat that as another presentation of the same work. The selected customer and open document can remain conceptually available while the layout changes how people move between them.

Sizing belongs in the design system as well. Consistent spacing, readable type, and shared component definitions help custom surfaces feel like one application. I prefer owned stylesheets for component styling, with genuinely dynamic geometry handled where the interaction requires it.

That keeps layout rules discoverable when a component needs to be repaired or reused.

Demonstrate one connected task

For a showcase, I would rather let someone complete a small task than present an empty desktop full of icons. Open a customer, inspect related equipment, bring up a project, and return to the original record. Every control should have a visible, understandable result.

That experience demonstrates composition, state management, interaction design, and business context together. It also makes limitations easy to identify: a local demonstration can clearly say that it uses sample records while still having fully working window behavior.

My practical takeaway is to define the continuity you want before choosing the window controls and visual details. Decide what stays open, what keeps its state, and how a person resumes interrupted work. Those decisions are what make the desktop metaphor earn its place in an application.