Plembfin: Open-Source Watch Status Sync Tool for Plex/Emby/Jellyfin

The Long-Standing Pain Point for Multi-Platform Users: Fragmented Watch Status

For users who run multiple media servers simultaneously, there's a persistent yet rarely solved pain point—watch status doesn't sync between platforms. You might finish an episode on Plex in your living room, only to find the progress bar reset to zero when opening Jellyfin on your phone. You mark shows as watched on Trakt, but Emby shows no response. This fragmentation creates a disjointed experience when using multiple platforms.

To understand the root of this problem, we need to look at how these platforms differ. Plex, launched in 2007, has the most mature client ecosystem and largest user base, but its core server is closed-source and has increasingly added cloud dependencies and advertising features in recent years, causing dissatisfaction among some users. Emby started as an open-source project but switched to a closed commercial model in 2018—it's feature-rich but requires payment to unlock premium functionality. Jellyfin is a fully open-source alternative forked from Emby after it went closed-source, licensed under GPL-2.0. While its client experience and plugin ecosystem are still catching up, it has gained rapid community support thanks to its pure open-source positioning. Trakt takes a different approach—it's not a media server but an online watch tracking service where users can log, share, and discover content, integrating with various players and media centers through APIs. Because these four platforms have highly overlapping user bases yet each maintains independent watch status databases, there's genuine demand for cross-platform synchronization.

An open-source project called Plembfin recently appeared on Reddit, built precisely to solve this problem. It's a self-hosted watch status sync hub designed to maintain consistency across Plex, Emby, Jellyfin, and Trakt. The project is open-sourced under the AGPL-3.0 license and is currently in pre-1.0 stage, with the author publicly seeking testers and technical feedback.

Plembfin's Core Design: No Single Source of Truth

Local SQLite as the Sync Coordination Hub

Plembfin's most noteworthy design philosophy is that it doesn't treat any single platform as the permanent "source of truth." This differs sharply from many sync tools—they typically enforce one platform as primary, with others passively following, meaning errors from the primary platform contaminate the entire data chain.

The "source of truth" is a core concept in distributed systems and data management, referring to designating one data source as authoritative when multiple copies exist, using that source's data to resolve conflicts. In media sync scenarios, traditional approaches usually set one platform (like Plex or Trakt) as the single source of truth, with other platforms syncing unidirectionally from it. While simple, this approach has obvious flaws: if the primary platform's data gets corrupted, suffers from user error, or the API returns anomalous data, the error cascades to all downstream platforms.

Instead, Plembfin maintains a local SQLite record as a hub to reconcile three key state types across platforms:

• Watched status: whether an episode/movie has been completed
• Playback progress: the exact minute where viewing stopped
• Repeat plays: how many times content has been rewatched

Plembfin's approach essentially introduces an "arbitration layer"—it collects status information from multiple sources, determines the final state through predefined conflict resolution strategies, then pushes results back to each platform. This design resembles "consensus mechanism" thinking in distributed systems. While more complex, it has fundamental advantages in fault tolerance and flexibility, more fairly merging information from different sources and avoiding data chaos from single points of failure.

Transparent and Inspectable Sync Process

Another highlight is sync process transparency. The author explicitly notes that many sync tools run like a "black box"—you don't know what they synced, when they failed, or why they failed. Plembfin provides visible sync activity logs, targeted retries, backups, and import tools.

This means users can actually inspect the sync process rather than blindly trusting it. When sync issues occur, you can pinpoint the specific step and manually retry—particularly important for error-prone scenarios like media library data synchronization.

Worth mentioning, one of the biggest technical challenges in cross-platform syncing is content matching. Different platforms use different metadata identification systems to recognize the same content: Plex uses proprietary Plex GUIDs and its Metadata Agent system, Jellyfin and Emby each maintain internal IDs, while Trakt primarily relies on public identifiers like IMDB ID, TMDB ID, and TVDB ID. The same movie might have completely different identifiers across platforms, or even different IDs on the same platform under different metadata agent configurations. More complex still, TV episode numbering can differ between databases—the same episode content might correspond to different season and episode numbers on TVDB versus TMDB. These differences mean sync tools must maintain a reliable cross-platform ID mapping mechanism, or risk incorrect state syncing or omissions. Transparent sync logs are especially critical in these scenarios, helping users quickly locate specific content matching failures.

Plembfin's Tech Stack and Docker Deployment

Plembfin's technology choices are pragmatic and well-suited for the self-hosting community:

• Backend: Node.js + Express
• Data storage: SQLite (lightweight, no separate database service required)
• Deployment: Docker Compose one-click deployment support
• License: AGPL-3.0 (strong copyleft ensuring derivative services must also be open-source)

For users familiar with Homelab and media server ecosystems, this combination means extremely low deployment barriers—a NAS or small server running Docker can handle it. The SQLite choice is particularly apt: as the world's most widely deployed database engine, it runs as a single file without requiring an independent database service process, with read/write operations directly through the filesystem. In Homelab environments, users typically run dozens of Docker containers on NAS or low-power small servers—each additional PostgreSQL or MySQL instance means extra memory usage, configuration maintenance, and backup complexity. SQLite's zero-configuration, zero-dependency characteristics perfectly avoid these issues. Its data file can be directly copied for backup, and can even be viewed and edited directly using generic SQLite browser tools, highly aligned with Plembfin's emphasis on being "transparent and inspectable." Of course, SQLite has limited concurrent write performance, but for personal or household-level watch status syncing, this bottleneck is almost never reached.

The AGPL-3.0 choice is equally worth understanding in depth. AGPL-3.0 (GNU Affero General Public License v3.0) is the network-extended version of GPL-3.0. GPL-3.0 requires providing source code when distributing modified software, but has a "SaaS loophole"—if a company only provides services over the network without distributing binaries, it doesn't trigger open-source obligations. AGPL-3.0 specifically closes this loophole: even if software is only provided as a network service, modifiers must provide complete source code to users. Historically, several well-known open-source projects (like Elasticsearch, MongoDB) were forced to change licenses after being directly packaged as commercial services by cloud providers without community contributions. Plembfin's choice of AGPL-3.0 legally ensures that any service built on its code—whether locally deployed or cloud-hosted—must remain open-source, important for protecting the sustainable development of small open-source projects.

A Typical Case of AI-Assisted Development

From "Tool" to "Collaborator"

The project has another detail quite characteristic of our era: the author candidly states that Plembfin was developed with extensive AI assistance, specifically implemented through "agentic workflows" under their guidance, review, and testing.

Agentic Workflows are an important trend in AI-assisted development since 2024. Unlike early AI programming assistants (like GitHub Copilot's autocomplete mode), agent workflows give AI greater autonomy—it can independently plan task steps, write code, run tests, analyze errors, and iterate fixes, with developers taking on the role of "architect and reviewer." Typical tools include Cursor's Agent mode, Claude Code, Devin, OpenHands, and others. In this mode, developers provide high-level requirement descriptions (like "implement Plex API watch status retrieval"), and the AI agent automatically consults API documentation, writes implementation code, handles error cases, and generates tests.

This reflects a real shift in current software development paradigms. Developers no longer hand-write every line of code, but play the role of "directing, reviewing, testing," delegating substantial implementation work to AI agents. This mode allows individual developers to produce structurally complete, fully functional projects in relatively short timeframes—covering multi-platform integration, database design, Docker deployment, backup and import tools, etc.—a workload that would be considerable under traditional development.

Code Quality Issues Worth Noting

Of course, AI-assisted development also brings issues worth community scrutiny. The author proactively emphasizes the project is in pre-1.0, needing review and bug feedback from people familiar with media server integration—itself a responsible attitude.

Media status syncing involves interfacing with multiple third-party APIs and handling edge cases (like matching IDs for the same content across platforms, timestamp precision differences)—precisely where AI-generated code can have vulnerabilities. AI-generated code may run well on "happy paths" but might not thoroughly consider edge cases like platform API rate limits, timeout retries, or partial data absence. Particularly, different platforms may have varying criteria for "watched" status (some platforms consider over 90% playback as completed, others require playing to the last minute), timezone handling for timestamps, and mapping relationships between different identification systems like GUID/TMDB ID/TVDB ID—all details prone to issues. Therefore, the "real user testing and code review" the project publicly seeks is crucial for reaching maturity.

Who Should Use Plembfin

Plembfin suits these user types:

• Homelab enthusiasts running two or more of Plex, Emby, or Jellyfin simultaneously
• Heavy Trakt users who want local playback to automatically sync to Trakt
• Technical users who require sync tool transparency and won't use black-box solutions
• Developers willing to participate in open-source testing, contribute code, or submit bugs

Note that as a pre-1.0 project, it's currently better suited as an "experimental trial" rather than a production dependency. Users wanting to try it can visit its GitHub repository (github.com/Lasikiewicz/plembfin) for documentation and screenshots, and are welcome to submit technical feedback to help push the project toward a stable release.

Summary

Plembfin addresses real pain points for multi-platform media users with its "neutral local database + transparent inspectable sync" design approach. Its tech stack is lightweight, deployment is simple, license is open, and it's also a typical case of individual developers producing complete projects in the AI-assisted development era. Though still in early stages, its design philosophy and open posture make it an open-source sync tool worth continued attention from the media server community.