ScreenJournal vs. ActivityWatch: From Logger to Analyst

ActivityWatch is brilliant. It's the gold standard for privacy-first, open-source time tracking. It logs every window title, every app switch, every keystroke event with millisecond precision—all stored locally, never touching a cloud server.

But here's the problem: window titles are opaque.

When ActivityWatch records bash or index.js - Visual Studio Code, it tells you almost nothing about what your developer actually did. Are they deploying to production or googling "how to center a div"? Writing API documentation or scrolling Twitter in a background tab?

At ScreenJournal, we built our entire architecture on top of ActivityWatch. We didn't fork it. We didn't replace it. We augmented it. We kept ActivityWatch's robust event collection and added the one thing it was missing: understanding.

The Window Title Trap

ActivityWatch collects high-fidelity data about which applications are active. A typical ActivityWatch log looks like this:

10:34:12 - Chrome - Stack Overflow - How to handle JWT expiration
10:35:47 - VS Code - auth-provider.tsx
10:42:19 - Terminal - bash
11:03:55 - Slack - #engineering

This is precise. It's accurate. And it's useless for business intelligence.

What you need to know:

• Did the developer solve the JWT expiration issue?
• What code did they write in auth-provider.tsx?
• Was the terminal session a production deploy or ls -la?
• Was the Slack time a productive technical discussion or watercooler chat?

Window titles can't answer these questions. ScreenJournal can.

The Context Void: When Metadata Isn't Enough

Let's walk through real scenarios where ActivityWatch hits its ceiling:

Scenario 1: The Terminal Black Box

ActivityWatch logs: bash - 47 minutes

What actually happened: Three possibilities:

• Running docker-compose up and monitoring production deployment logs
• Debugging a database migration script that failed
• Running ping localhost and watching YouTube in another window

ActivityWatch can't distinguish between these. ScreenJournal's computer vision analyzes the terminal content and reports: "Debugging database migration errors in staging environment. Resolved foreign key constraint issue."

Scenario 2: The Browser Ambiguity

ActivityWatch logs: Google Chrome - 2 hours 15 minutes

What actually happened: Unknown. Chrome could be:

• Reading React documentation
• Debugging in DevTools
• Scrolling Twitter
• Reviewing GitHub PRs
• Watching Netflix

Browser extensions can grab URLs, but they can't see what you're doing on the page. ScreenJournal's visual analysis identifies: "Chrome DevTools open, debugging React component re-render issue. Console shows 47 warning messages related to state updates."

Scenario 3: The IDE Mystery

ActivityWatch logs: VS Code - main.py - 3 hours

What actually happened: Five possibilities:

• Writing 500 lines of new feature code
• Staring at a syntax error for 2 hours
• Reading existing code to understand architecture
• File open but attention on Stack Overflow in background
• Pair programming via Zoom screen share

Without GitHub integration, you can't measure output. ScreenJournal correlates the 3 hours in VS Code with your GitHub commits: "Wrote 347 lines across 4 files. Implemented user authentication system. Pushed commit 7b3f to feature/auth branch."

The Architecture: ActivityWatch + Computer Vision

We treat ActivityWatch as our sensory nervous system—it gives us the "where" (which app is open) and "when" (precise timestamps). We then built a visual cortex on top to provide the "what" and "why."

The ScreenJournal Pipeline:

Layer 1: ActivityWatch Event Collection

Our desktop client runs a local ActivityWatch instance to capture window switching events:

{
  "timestamp": "2026-01-12T10:34:12Z",
  "app": "Visual Studio Code",
  "title": "auth-provider.tsx",
  "duration": 1847
}

Layer 2: Screen Recording (Ephemeral)

Simultaneously, we record screen activity in encrypted 60-second chunks. This is temporary storage—the video never leaves the local machine until processing.

Layer 3: AI Processing (Gemini)

We send the video chunk + ActivityWatch metadata to Google Gemini with a strict prompt:

Analyze this screen activity. The user had "VS Code - auth-provider.tsx" open for 30 minutes.

INSTRUCTIONS:
- What specific task were they performing?
- What code context is visible?
- Are there any error messages or debugging activities?
- Correlate with window title to provide semantic understanding.

CRITICAL PRIVACY RULE:
- Ignore all PII, passwords, API keys, private messages
- Return only high-level work context in JSON format

Layer 4: The Goldfish Protocol (Kill Switch)

Once Gemini returns the JSON metadata, the video file is immediately and permanently deleted. It never reaches cloud storage. We call this ephemeral processing.

Layer 5: Storage (InfluxDB)

We store the clean, anonymized text metadata alongside the ActivityWatch event log:

{
  "timestamp": "2026-01-12T10:34:12Z",
  "app": "VS Code",
  "window_title": "auth-provider.tsx",
  "activity_watch_event_id": "aw-47392",
  "context_summary": "Refactoring JWT validation logic. Fixing token expiration handling bug.",
  "category": "Development - Authentication",
  "privacy_flag": false,
  "video_deleted_at": "2026-01-12T10:35:15Z"
}

The Result: Semantic Understanding

We didn't replace ActivityWatch. We gave it comprehension.

Privacy Preservation: Both Local-First, Different Use Cases

ActivityWatch and ScreenJournal share the same core philosophy: privacy by design.

ActivityWatch's Privacy Model:

• All data stored locally on user's machine
• Zero cloud sync by default
• User has complete control over data
• Perfect for personal productivity tracking

ScreenJournal's Privacy Model:

• Video processing happens in encrypted cloud (necessary for team analytics)
• Video is deleted immediately after AI processing
• Only text metadata stored
• Designed for business environments with compliance requirements

The key difference: ActivityWatch is optimized for individual use where you control the data. ScreenJournal is optimized for team use where managers need visibility but employees need privacy protection.

Both approaches prioritize privacy. ActivityWatch says "your data never leaves your machine." ScreenJournal says "the sensitive data (video) is destroyed immediately, and only sanitized insights are shared."

The Business vs. Personal Use Case

ActivityWatch was designed for a solo developer asking: "Where did my day go?". It's a personal accountability tool. You review your own logs, identify time sinks, and adjust behavior.

ScreenJournal was designed for an engineering manager asking: "How do I support a team of 50 remote developers without micromanaging them?"

What ActivityWatch Can't Do:

• Multi-tenant architecture: ActivityWatch doesn't have user accounts, team dashboards, or role-based access control
• Aggregate analytics: No way to see team-wide patterns like "average context-switch rate" or "deep work trends"
• Compliance features: No audit logs, data retention policies, or GDPR export functionality
• Manager insights: The entire system is designed for self-review, not team oversight
• GitHub integration: No correlation between time spent and code delivered
• Natural language queries: You manually parse JSON logs instead of asking "Who needs focus time coaching?"

ScreenJournal provides all of these while maintaining ActivityWatch's privacy principles through ephemeral video processing and metadata-only storage.

The Technical Deep Dive: InfluxDB Integration

Both ActivityWatch and ScreenJournal use time-series databases, but for different purposes.

ActivityWatch's Approach:

• Stores raw event logs locally
• Uses SQLite or similar embedded database
• Optimized for single-user queries like "show me my Firefox usage today"

ScreenJournal's Approach:

• Stores enriched metadata in InfluxDB (cloud-based time-series DB)
• Optimized for team-wide queries like "show average deep work time across engineering team this quarter"
• Supports complex aggregations: "Which employees show burnout risk patterns based on context-switch acceleration?"

InfluxDB allows us to run analytics that would be impossible with ActivityWatch's local storage model:

• Trend analysis: "Your team's productivity increased 12% after implementing No-Meeting Wednesdays"
• Comparative benchmarks: "Developer A ships 3x more code per hour than team average—what are they doing differently?"
• Predictive alerts: "Developer B's focus time dropped 40% in 3 days—check in for potential burnout"

These queries require centralized data storage and high-performance time-series aggregation. ActivityWatch wasn't built for this.

The GitHub Extension: Output Measurement

ActivityWatch logs tell you "time spent." ScreenJournal's GitHub integration tells you "value delivered."

When a developer pushes code, we ingest the GitHub webhook payload:

{
  "commits": [{
    "id": "7b3f1a",
    "message": "fix: optimize jwt parsing logic",
    "timestamp": "2026-01-12T14:00:00Z",
    "added": ["src/lib/auth.ts"],
    "modified": ["src/api/login.ts"],
    "deletions": 23,
    "additions": 47
  }]
}

We correlate this with the ActivityWatch + ScreenJournal timeline:

• 10:00 AM - 2:00 PM: 4 hours in VS Code (ActivityWatch event)
• Context: "Debugging JWT token expiration issue" (ScreenJournal AI analysis)
• Output: Commit 7b3f - "optimize jwt parsing logic" (GitHub integration)
• Impact: Login latency reduced from 450ms to 200ms (extracted from commit diff/PR description)

Now your daily standup report writes itself: "Spent 4 hours debugging and refactoring authentication. Deployed fix reducing login latency by 55%."

ActivityWatch can't provide this level of business intelligence.

When to Choose ActivityWatch vs. ScreenJournal

Choose ActivityWatch if:

• You're a solo developer tracking personal productivity
• You want 100% local data storage with zero cloud dependency
• You're comfortable manually reviewing JSON logs
• You don't need team analytics or manager dashboards
• Privacy means "my data never leaves my machine"
• You're building custom integrations on top of open-source tools

Choose ScreenJournal if:

• You manage a remote engineering team (5+ developers)
• You need aggregate team analytics and trend reporting
• GDPR compliance and audit logs are requirements
• You want natural language queries instead of manual log parsing
• You need to correlate time spent with work delivered (GitHub commits)
• Privacy means "sensitive data is destroyed, insights are preserved"
• You want ActivityWatch's data quality with enterprise features

Open Source as Our Foundation

We're often asked: "Why not just fork ActivityWatch?"

Because ActivityWatch already solved the hard problem: reliable, cross-platform event collection. Their window tracking is bulletproof. Their timestamp precision is excellent. Their local storage model is privacy-first.

We didn't need to reinvent that wheel. We needed to add the missing piece: semantic understanding of what those events mean.

Our roadmap includes open-sourcing the local version of ScreenJournal. When we do, it will include ActivityWatch as a core dependency. We're standing on the shoulders of giants, not competing with them.

For more on our open-source philosophy, see Why We Built on Top of Open Source.

Stop Logging, Start Understanding

ActivityWatch tells you that you spent 8 hours on your computer today. ScreenJournal tells you that you:

• Shipped 3 features across 12 commits
• Spent 4.5 hours in deep work (focus sessions >60 minutes)
• Had 47 context switches (12% above your baseline—investigate meeting load)
• Debugged 2 production issues with average resolution time of 35 minutes
• Need coaching on Slack discipline (checking every 6 minutes)

One is a log. The other is intelligence.

If you're a solo developer who wants to understand your own habits, ActivityWatch is perfect. If you're an engineering leader who needs to support a team without surveillance, ScreenJournal is the answer.

---

Ready to upgrade from logging to understanding? Join the ScreenJournal beta and see what ActivityWatch + AI can do for your team.