Review: phpIP - An Open-Source Tool for Managing Patents

The patent sector offers numerous software tools, but as a proponent of open-source and self-hosted solutions, I chose phpIP as the first tool to review. Here’s an overview.

phpIP is a web-based platform. Its creators describe it as

a web tool for managing an IP rights portfolio, especially patents. It is intended to satisfy most needs of an IP law firm. The tool was designed to be flexible and simple to use. 

Here are some key features:

• Flexible Data Entry: Create and manage entries like patents, trademarks (Matters), and clients (Actors).
• Renewal Management: Includes email reminders for timely updates.
• Events and Task System: Organize and track general events and tasks efficiently.
• EPO OPS Integration: Enrich data with public patent information directly from EPO OPS.
• User-Specific Dashboard: Tailored views for individual users.

In the IP domain, open-source software (FOSS) provides critical benefits:

• Data Security: Self-hosting ensures sensitive patent data isn’t exposed to third-party cloud providers, mitigating risks of leaks.
• Customization: Adaptable solutions align with internal workflows, giving firms a competitive edge.

When considering open-source tools, evaluate the following:

• Feature Fit: Does it meet your specific needs?
• Project History: Initial commit >6 years ago. ✔
• Active Development: Last commit ~3 months ago. ✔
• License: Compatible (GPL-3.0). ✔
• Contributors: More than one, though not many (~1.x). ✔
• Open Issues: No major unresolved bugs. ✔
• Community Interest: Stars, forks, watchers (40, 17, 11). ✔
• Tech Stack: Modern (PHP 8, Laravel 11). ✔
• Codebase Quality: Solid, though lacking tests. ✔
• Documentation: Setup and usage guides available. ✔
• Financial Backing: Supported by a patent firm (Omnipat). ✔

While phpIP is promising, the lack of a working demo posed a challenge. The provided Docker setup had configuration issues, and there was no pre-built Docker image available on Docker Hub. To address this and support the project, I deployed a public demo instance to evaluate the tool:

For those interested in the technical aspects, here’s a summary of how I set up phpIP. While there are numerous ways to achieve this, these steps outline my approach. I go into detail here not only to demonstrate a practical method for deploying such a web application but also to highlight that the process is manageable and not as complex as it might seem.

Secure Server

• Gain root access to a secure server accessible to intended users.
• For this demo, I used a virtual server from Hetzner Cloud.
• In production, you’d typically use an internal server accessible via your company’s VPN.

DNS Configuration

• Configure DNS to route users to the server under your chosen domain.
• I used Cloudflare to set up the A-record. (If your company lacks a DNS server, Cloudflare DNS can handle internal IPs with Let’s Encrypt support for automatic TLS)
• Ensure compliance with any company network restrictions (e.g., proxies).

Application Requirements

• phpIP requires a web server, a database server, and a specific PHP version.
• Since the server will host multiple demos, including potential PHP version conflicts, I opted for Docker in Swarm mode to manage applications.

Reverse Proxy Setup

• Implement a reverse proxy to handle SSL/TLS and manage multiple applications sharing ports 80/443.
• I used Traefik, which also auto-generates SSL/TLS certificates.
• For production environments, you might need to obtain certificates from your internal authority. TLS is essential to encrypt user-server communication.

Containerization & Database

• I built a custom Docker image for the application and used a standard image for MySQL
• After configuring the necessary environment variables, I executed the database migrations
• The application is now live at: https://phpip.demo.patent.dev

If I notice interest in the demo, I plan to fork the repository, include a link to the GitHub repo, and add an environment variable for demo mode. This mode will display demo credentials and implement a cleanup job to reset the database periodically.

Making this tool easier to test would likely encourage more users to explore it. With the demo now available, let’s see how it functions.

I opted not to add sample data, so you’ll see the blank version upon accessing it. To log in, click on “Login” and use the default credentials: phpipuser / changeme.

This works as intended and directs you to the empty dashboard.

I find the interface lacks self-explanatory elements. However, the underlying concept is solid and well-designed. For details, I’ll defer to the documentation provided in the wiki.

The design principle of using a generic entity called “Matter” to represent items such as patents, litigations, or other related entities is a sophisticated way to maintain flexibility and avoid data duplication. However, it necessitates that users understand and retain this abstraction, which can contribute to a steep learning curve. For tools used infrequently, this abstraction might pose challenges as users may struggle to recall the core concepts. Nevertheless, since this tool is intended for regular, weekly, or daily use, this limitation becomes less critical. The primary benefit of this approach lies in its ability to streamline and optimize process management efficiently.

Here are some screenshots with sample data to give you an idea of how it looks in practice.

Naturally, I was curious about the EPO OPS integration, so I connected the API to PhpIP. The implementation appears a bit rough around the edges, which the creators are aware of:

Use with caution, as we have not tested all the possible complex cases. Check in particular the links between multiple filings in the same country (divisions, continuations, internal priorities).

The first publication number I tested resulted in an error:

The issue lies in how the code handles missing data from EPO OPS. When certain data, such as the title in this case, cannot be retrieved as expected, the code still attempts to access it. This absence of data triggers an error message, reflecting a lack of polished error handling for such scenarios.

However, I had success with US5156935A:

Overall, it’s an impressive tool, and it’s fantastic that the creators chose to open source it, allowing users to utilize it freely and customize it as needed.

If you’d like a deeper dive into the features, a review of other tools, or assistance with setting up, customizing, or developing patent software solutions, feel free to reach out! I’d love to hear from you at info@patent.dev.