EveryDocs

EveryDocs Core is a lightweight, self‑hosted Document Management System (DMS) written in Ruby on Rails. It exposes a RESTful API for CRUD operations on documents, folders, persons, and processing states while also serving a mobile‑friendly web interface. The system focuses on simplicity for private use but offers enough extensibility for developers to integrate into larger ecosystems. From a technical standpoint, the core handles PDF ingestion, optional encryption, full‑text search via extracted content, and JWT authentication.

Architecture & Technical Stack

• Framework: Ruby on Rails 7, leveraging ActiveRecord for ORM and ActionCable for optional real‑time features.
• Language: Ruby 3.x, with a small amount of JavaScript for the web UI.
• Database: PostgreSQL (recommended) or SQLite for lightweight setups; the schema is versioned with Rails migrations.
• Storage: Files are persisted on disk under a configurable directory (/var/everydocs-files by default). Encryption is optional per user and implemented using AES‑256 via the openssl Ruby bindings.
• Search: Full‑text search uses PostgreSQL’s tsvector on extracted PDF text; if encryption is enabled for a user, the extraction step is skipped and search falls back to metadata only.
• Authentication: Stateless JWT tokens issued on login; secret key is supplied via SECRET_KEY_BASE.
• Containerization: A Docker image is provided (jonashellmann/everydocs) with a multi‑stage build. Docker Compose bundles Postgres, the API, and the web UI in three containers.

Core Capabilities & APIs

• Document Lifecycle: Upload, update, delete, and retrieve PDF files along with title, description, creation date, owner, and custom tags.
• Folder Hierarchy: Nested folders are stored as a self‑referencing table; API endpoints allow moving, renaming, and querying by path.
• People & States: CRUD for “persons” (e.g., stakeholders) and “processing states” (workflow stages). Documents can be linked to multiple persons or states.
• Search API: /search?q=... supports query across title, description, and extracted content. Pagination and sorting are available.
• Webhooks: While not native, developers can subscribe to ActiveRecord callbacks (after_create, after_update) and expose custom endpoints.
• Extensibility: The Rails engine structure allows mounting the core into larger applications or adding custom controllers and services. Plugins can be added as Rails gems that hook into the after_* callbacks.

Deployment & Infrastructure

• Self‑Hosting: Minimal requirements – a machine with Docker, a PostgreSQL instance, and a writable file store.
• Scalability: The API is stateless; horizontal scaling can be achieved by load‑balancing multiple containers behind a reverse proxy (NGINX, Traefik).
• Persistence: Data is persisted in PostgreSQL; file storage can be replaced with networked filesystems (NFS, S3 via aws-sdk) by overriding the storage path.
• Backup: Regular database dumps and file snapshots are recommended; encryption keys must be securely stored to decrypt user files.

Integration & Extensibility

• RESTful Hooks: External systems can consume the API to ingest documents or trigger processing workflows.
• SDKs: No official SDK, but the JSON API is straightforward; developers can generate clients in any language.
• Webhooks / Callbacks: By extending the Rails callbacks, you can trigger external services (e.g., Slack notifications) when a document is uploaded or moved.
• Custom Fields: The database schema can be extended with additional columns; migrations preserve backward compatibility.

Developer Experience

• Documentation: The README covers Docker usage, API endpoints, and encryption setup. Inline code comments aid navigation.
• Community: The project is open source on GitHub with active issue tracking; contributors can fork, submit PRs, and discuss enhancements.
• Configuration: Environment variables (SECRET_KEY_BASE, DATABASE_URL) control authentication, database connectivity, and storage paths.
• Testing: RSpec tests cover API routes, model validations, and encryption logic; CI runs on GitHub Actions.

Use Cases

• Personal Knowledge Base: A developer can host a private DMS for research papers, contracts, and project documentation.
• Team Collaboration: Small teams can use the API to integrate document uploads into CI/CD pipelines or issue trackers.
• Compliance Audits: Encrypted storage per user satisfies data‑at‑rest requirements while the API allows audit logging.
• Custom Workflows: By hooking into processing states, developers can build approval chains or automated PDF parsing services.

Advantages

• Performance: Rails’ built‑in caching and PostgreSQL full‑text search provide quick retrieval for moderate workloads.
• Flexibility: The core can be embedded into larger Rails applications or exposed as a microservice.
• Licensing: MIT license allows unrestricted use, modification, and redistribution in commercial products.
• Simplicity: Zero‑config Docker setup makes onboarding fast, while the API remains simple enough for rapid prototyping.

EveryDocs Core delivers a developer‑friendly, self‑hosted DMS that balances out‑of‑the