Is Software Design Patentable? Non-Obviousness and Patentability

You may be wondering if your software design is patented, if it’s non-obvious, and if it’s worth tying every software developer up in bureaucracy. Well, there are several ways to avoid a patent. Avoiding features patented by competitors is one easy way, but avoiding others is a tougher task. Sometimes, you can’t avoid all patented features, but some of them are important and may not be a viable option for you. For example, the software XyWrite had recently received a downgrade because it removed the feature that pre-defined abbreviations. Abbreviations were pre-defined, and typing them would expand the punctuation character automatically.

Is software design patentable?

There is some debate as to whether software design is patentable. There is no specific definition for what software is deemed patentable, but some areas are more eligible for patents than others. For example, a lookup table or archiving system may be patented but not a feature of the software. On the other hand, a solution that solves a specific pain point for the customer is more likely to be patented than one that doesn’t.

To qualify for a design patent, a product’s appearance or functionality must differ from any existing product. It should also serve some useful purpose, but not be obvious to the public. Patent protection under this category can last for up to 20 years, although the PTO can take three years to grant a patent. Thus, the actual period of protection may only be seventeen years. If it’s clear that the design is not obvious, the software may not be patentable.

While software is becoming increasingly useful, it has a stigma. The media often considers software as abstract and non-technical. It’s falsely perceived as being irrelevant to practical use, because it’s done by people who think they know better. That’s why software has been a target for patents. It’s easy to see why programmers are concerned. The media, on the other hand, trawls through patent news sources and finds ways to make a story more interesting.

The USPTO has issued guidelines for patenting software designs. While they aren’t final, they are continuously changing due to the decisions of the Supreme Court and the Federal Circuit. The 2013 guidelines were helpful in guiding the USPTO in determining whether a software design should be patented. In a recent case, Alice Corp. v. CLS Bank led to the creation of a patent on a combination of ideas. The Supreme Court held that software is a new idea, and the patented software packages are usually abstract.

As an abstract idea, software can still qualify for a patent if the code used is “abstract” and solves a problem that is “necessarily rooted in computer technology. However, it must solve the problem in an unconventional way, and the claims must not preempt every possible application of the idea. It should be noted, however, that it is rare to find a patent on software design that does not meet these requirements.

Is it non-obvious?

The question of nonobviousness in patent applications is not an easy one to answer. The ambiguous definition of nonobviousness can make patent applications harder to win. As Rolla points out, an example of a non-obvious software design might be a pivoting briefcase handle. If you invented a pivoting briefcase handle and patented it, you’d likely get a rejection because it’s a simple extension of a suitcase handle.

Is it patentable?

Software design is patentable because it’s new. There are several things that make it new. Software packages are often large and contain many different ideas. The software program itself must be new, or it doesn’t qualify for a patent. That is why software developers are often skeptical that their programs are patentable. There are some exceptions to this rule, though. If a software package is truly new and uses a new piece of code, it may be patentable.

The main reason why software patents are so controversial is that they often encroach on trivial inventions, which inhibits innovation and development. While some countries have stricter guidelines for patenting software, the European Patent Directive (EPC) takes a different approach. In Europe, for example, software patents are generally not patentable unless an original idea involves an “inventive step”.

Software startups are notoriously expensive. The startup costs alone can top six figures. By foregoing a patent, a software developer leaves themselves open to the risk of their software being copied by competitors. The risk of being sued is significant. Fortunately, avoiding a patent is easier than you think. There are ways to protect your software and avoid risk, while maintaining the privacy of your customers. But remember that patents are expensive and can cripple your program.

The European Patent Office (EPO) is also trying to clarify software patents. It’s still unclear what the EPO’s rules will look like, but this decision is expected to be made soon. In the meantime, the US government may decide to make software patents available in the EPO. The European Patent Office (EPO) is also considering a directive that says software cannot be patented. That would create new problems for both patent holders and software developers.

Most inventions today are computer programs or digital products. While this does not mean that a product isn’t patentable, it is worth considering whether its design has an effect on people’s lives. The EPO uses a term called “technical effect” to describe software ideas, which stretches the definition tremendously. If it had a legal definition, then software could be patentable if the idea was directly related to a specific physical result.

Does it tie up every software developer in a new form of bureaucracy?

Software code is a bureaucracy, written by the programmer or rule-maker who codifies the expected behavior of the software or its users. The code is embedded in a business process, which is specified by a user manual, SOP document, a tradition of using the software, or instructions from a pointy-haired manager. Its purpose is to automate tasks by defining the exact rules the software must follow to achieve its objective.