Same Data Many Interfaces

Same Data Many Interfaces

Interface is part of the tool. Right interface for each context beats one complex interface.

The Pattern Across Projects

Scrapbook-core has 4 ways to access the same 9,485 scraps:

• Alfred workflow (Cmd+Space → instant search)
• Web dashboard (visual browsing, realtime updates)
• Mobile scroller (replace doomscrolling)
• CLI/SQLite (when you're in terminal)

Coach Artie has 3 interfaces to same AI brain:

• Discord (async, group context)
• SMS (mobile, emergency)
• Web UI (visual, configuration)

Personal APIs expose the same data to multiple consumers:

• AI assistants (Claude, Coach Artie get full context)
• Website widgets (live stats display)
• Mobile apps (health dashboard)
• CLI tools (terminal queries)

Why This Matters

Data stays useless until accessed. Interface shapes what's possible. Context determines ideal mode. No single "best" interface.

Example from real use

Time	Context	Interface Choice
Morning (coffee)	Visual browsing, relaxed	Scrapbook web dashboard, traditional news view
Midday (focused work)	Instant access, no context switch	Alfred workflow, dense news view
Mobile (away from desk)	Quick questions while traveling	SMS for Coach Artie, mobile scroller
Terminal (deep work)	Precise queries, pipe to tools	SQLite queries, CLI everything

The Design Philosophy

Not:

• Building features for the sake of features
• "Omnichannel" marketing speak
• Trying to be everything to everyone

Is:

• Recognizing different contexts have different needs
• Same data, accessed differently depending on mode
• Interface choice as part of the tool
• Right tool for right job

Technical Architecture

[Data Layer] (single source of truth)
     ↓
[API Layer] (consistent access, shared logic)
     ↓
[Interface Layer] (multiple, context-specific)
├─ Alfred (search)
├─ Web (browse)
├─ Mobile (scroll)
└─ CLI (query)

Key insight:

• Logic lives in middle layer
• Interfaces are thin wrappers
• Adding new interface ≠ rewriting logic
• Each interface optimizes for its context

This architecture enables long-term data capture without locking you into one way of seeing it.

Context-Driven Examples

Scrapbook Alfred

• Context: Writing code, need to reference article
• Mode: Don't want to leave terminal/editor
• Interface: Cmd+Space, type "sc [query]", get result
• Speed: < 2 seconds from thought to answer

Scrapbook Web Dashboard

• Context: Morning coffee, curious what's new
• Mode: Relaxed browsing, visual exploration
• Interface: Realtime updates, card-based UI
• Speed: Doesn't matter, enjoying the process

Scrapbook Mobile

• Context: Waiting for train, bored
• Mode: Replace Instagram scrolling with your own content
• Interface: Infinite scroll, swipe-friendly
• Speed: Matches social media muscle memory

Scrapbook SQLite CLI

• Context: Deep in terminal, researching pattern
• Mode: Need precise queries, not browsing
• Interface: SQL queries, pipe to other tools
• Speed: Instant, no UI overhead

When NOT to Build Multiple Interfaces

Don't build if:

• Core interface isn't solid yet
• Just for the sake of it
• No clear contextual need
• Maintenance burden too high

Do build when:

• Different contexts have different needs
• Switching contexts is frequent
• Each interface enables new behavior
• Shared data layer already exists

What I Learned

About interfaces:

• One size fits none
• Context determines ideal mode
• Muscle memory matters (Alfred vs CLI)
• Visual vs textual: different thinking modes

About data:

• Data wants to be accessed many ways
• Storage format ≠ access format
• Same query, different presentations
• Structure enables multiple interfaces

About users (me):

• Morning self ≠ afternoon self
• Mobile context ≠ desktop context
• Browsing mode ≠ search mode
• Each mode valuable for different reasons

The Meta-Pattern

Desktop ≠ mobile ≠ terminal

Browsing ≠ searching ≠ querying

Visual ≠ textual ≠ audio

Same data, different shapes. Interface is part of the tool.

Related

• Scrapbook-core - 4 interfaces to same data
• Coach Artie - 3 interfaces to same AI brain
• Personal APIs - multi-modal data access
• Quantified Self - tracking that feeds the interfaces
• Building Tools for Yourself - why personal tools enable this pattern
• Appropriate Technology - choosing right tool for context