How Lumenci proved non-infringement by testing the traffic, not just reading the code
Source code shows what a system is meant to do.
Lumenci captured the actual exchanges between app and server, despite the security around them, and showed what it did.
.webp "Feature images - 2026-05-07T163421.509 (convert.io)")
Case at a Glance
Domain
Service
Client
Outcome
Summary judgment for the defense, and an end to a case that could have run for years.
If This Sounds Like Your Case
You are defending an infringement claim and the accused functionality lives in an app talking to a backend
The source code alone does not settle what the system actually does at runtime
Client-server traffic is encrypted, so standard capture methods do not get you inside it
You want this resolved on the papers, not argued in front of a jury
A case goes to a jury when the technical facts are in dispute. Captured traffic left nothing to dispute.
What most teams do.
What Lumenci did instead.
Built a way to capture and analyse the actual client-server exchanges, despite the security measures in place.
Why it mattered.
How It Was Done
Lumenci worked as an extension of the litigation team, staffed with engineers who could read a geolocation stack at the algorithm level and testers who could get inside an encrypted client-server exchange.
The geolocation and routing implementation was reviewed in detail, including driver tracking and estimated arrival algorithms, to establish what the accused system was built to do.
With the client-server communications protected, a testing approach was developed to capture and analyse the exchanges as they actually occurred between the app and the backend.
UI, UX, and backend behaviour were examined together, so the technical picture covered what the user sees as well as what the system sends.
Findings were translated into the non-infringement position, in a form that could carry through briefing rather than sitting in a technical annex.
What Changed for the Client
Where they stood.
A non-infringement position resting on observed system behaviour, not on a reading of the code
What it forced.
The plaintiff had to contest captured traffic data rather than argue over competing interpretations of source code
How it ended.
Summary judgment granted, ending the case before trial
Source Code Review for Patent Litigation
100k+ Patents Analyzed
200+ Source Code Reviews
250+ Litigations Supported
What This Would Look Like for Your Matter
A scoping conversation covers the accused functionality, what has been produced, whether the system's runtime behaviour has been tested at all, and your summary judgment or expert report dates. You get a view of what testing can establish before committing to a full engagement.
Frequently Asked Questions
Why isn't source code review enough in an app-based patent case?
Code tells you how a system is written. It does not always tell you what happens when the app runs against a live backend, particularly where behaviour depends on server responses, configuration, or conditions that only exist in production.
Can encrypted client-server traffic be analysed for patent litigation?
It can, though standard capture tools usually will not get you there. It takes a testing method built for the specific application and its security model, which is why this work is generally scoped as method development rather than as a review task.
What does traffic testing add to a non-infringement defense?
Evidence of what the system did, rather than an argument about what the code means. That is a materially harder position for a plaintiff's expert to dispute, because it moves the question from interpretation to observation.
What does it take to win non-infringement at summary judgment?
A technical record clear enough that there is no genuine dispute of material fact for a jury to resolve. Ambiguity favours the plaintiff at that stage, so the evidence has to close the question rather than argue it.
Does Lumenci build custom testing methods, or only use standard tools?
Both. Where standard tools reach the evidence, we use them. Where they do not, as here, we develop a testing approach for the specific system. That work sits within our technical testing and litigation support practice.
Does Lumenci work with the testifying expert, or replace them?
We work alongside the testifying expert, building the technical record and preparing them for deposition. Where a matter needs testimony from us directly, Lumenci also provides expert witness testimony.