Patents & Intellectual Property

Patent Fundamentals

The three requirements for patentability, types of patents, and what the Alice Corp decision means for software developers.

What Is a Patent?

A patent is a government-granted exclusive right to make, use, sell, and import an invention for a limited period (typically 20 years from filing). In exchange, the inventor publicly discloses the invention in detail, contributing it to the public domain when the patent expires.

Patents are territorial. A U.S. patent does not protect your invention in Europe. International protection requires filing in each jurisdiction or using the Patent Cooperation Treaty (PCT) process.

Three Requirements for Patentability

To be patentable, an invention must satisfy three requirements:

1. Novel

The invention must be new. It cannot have been previously disclosed, sold, or patented anywhere in the world. Even your own prior publication can prevent you from patenting — if you describe your invention publicly, you typically have a 1-year grace period in the U.S. to file (but not in most other countries, where public disclosure before filing is an immediate bar).

2. Non-Obvious

The invention must not be obvious to a "person having ordinary skill in the art" — someone with typical expertise in the relevant field. This is the hardest requirement to satisfy. Combining two known technologies in a way that's predictable is usually obvious. Finding an unexpected result from that combination might not be.

3. Useful

The invention must have a specific, substantial, and credible utility. This is rarely a barrier for functional software innovations, but pure research results without practical application may not qualify.

Types of Patents

Utility Patents — Cover functional aspects of inventions: how something works, how it is used, how it is made. Most software patents, when granted, are utility patents.

Design Patents — Cover the ornamental appearance of a product. Less relevant for software but occasionally used to protect distinctive UI designs.

Provisional Patent Applications — Not a full patent, but a 12-month placeholder that establishes a priority date. Much cheaper ($320 for micro-entities, $800 for small entities) and less detailed than a full utility patent application. The 12-month clock starts ticking the day you file.

The Alice Corp Decision and Software Patents

In 2014, the U.S. Supreme Court decided *Alice Corp. v. CLS Bank International* (573 U.S. 208). This decision fundamentally changed what software is patentable.

The Alice Test (Two Steps)

Step 1: Is the claim directed to an abstract idea, a law of nature, or a natural phenomenon? (If yes, proceed to Step 2.)

Step 2: Does the claim include elements that transform it into something "significantly more" than the abstract idea itself?

What Is NOT Patentable After Alice

  • Abstract business methods implemented on a generic computer ("apply it on a computer")
  • Mathematical formulas or algorithms without a specific technical application
  • Organizing information into categories
  • Performing a known business practice using the internet

What IS Generally Still Patentable

  • Novel algorithms that solve a specific technical problem in a computer system (not just a business problem)
  • Methods that measurably improve a computer's performance, security, or efficiency
  • Specific technical implementations that go beyond the abstract idea
  • Hardware innovations with software components

The practical result: getting a pure software patent is significantly harder since Alice. Many applications are rejected at Step 1 or Step 2. Patent attorneys have developed strategies to draft claims that survive the Alice test, but it requires careful drafting and strong technical specificity.

Example

markdown
// Patent eligibility pre-screening checklist
interface PatentClaim {
  title: string;
  description: string;
  technicalImprovement: string | null;
  usesGenericComputer: boolean;
  abstractIdea: string | null;
}

function preScreenPatentEligibility(claim: PatentClaim): {
  likelyEligible: boolean;
  reasons: string[];
  recommendation: string;
} {
  const reasons: string[] = [];
  let eligibilityScore = 0;

  if (claim.technicalImprovement) {
    eligibilityScore += 3;
    reasons.push('+ Specific technical improvement: "' + claim.technicalImprovement + '"');
  }

  if (!claim.usesGenericComputer) {
    eligibilityScore += 2;
    reasons.push('+ Does not rely on generic computer implementation');
  } else {
    eligibilityScore -= 2;
    reasons.push('- Relies on generic computer — Alice risk');
  }

  if (claim.abstractIdea) {
    eligibilityScore -= 3;
    reasons.push('- Abstract idea found: "' + claim.abstractIdea + '" — must add "significantly more"');
  }

  const likelyEligible = eligibilityScore > 0;
  const recommendation = likelyEligible
    ? 'Consider filing. Work with patent attorney on claim drafting.'
    : 'High Alice rejection risk. Consider trade secret or defensive publication instead.';

  return { likelyEligible, reasons, recommendation };
}

const exampleClaim: PatentClaim = {
  title: 'Method for reducing database query latency',
  description: 'A system that predicts and pre-caches query results based on user behavior patterns',
  technicalImprovement: 'Reduces average query response time by 40% through adaptive prefetching',
  usesGenericComputer: false,
  abstractIdea: null,
};

console.log(preScreenPatentEligibility(exampleClaim));
Try it yourself — MARKDOWN