Plugins in websites, apps or generally in software - what are those? Those are pieces of code, usually entire enclosed functions that work independently of the basic system. They are downloadable for free or paid with little time to setting it up.

As a client, you like the sound of that, am I right? I would. But I have the experience and it’s not as great as it sounds.

Having worked in the industry for over 15 years, as a developer, manager and growing business owner, I've seen firsthand how overreliance on plugins can lead to a multitude of problems. Here's why developers should consider writing custom code instead of downloading third-party solutions, and why you, as a client, should care.

1. Security Risks

Third-party plugins can contain harmful code that compromises the security of your server, users, or even the developer's own machines. Since these plugins are often developed by unknown parties, they might not adhere to the highest security standards. This opens up vulnerabilities that malicious actors can exploit, leading to data breaches or other cyber threats.

The prevention could be to inspect thoroughly the downloaded code, which developers will not do since it is even more time-consuming than writing it from the scratch.

2. Performance Issues

Plugins can slow down your website or application due to:

• Overly Complex Code: Many plugins are designed to be one-size-fits-all solutions, containing extra code that your project doesn't need, but still executes.
• Lack of Optimization: Plugins may not be optimized for performance, leading to longer load times and a poor user experience.
• Incompatibility: Plugins designed to support legacy browsers or outdated systems add unnecessary overhead, further degrading performance.

3. Limited Customization

Clients have their needs and require the product to be in certain way, therefore request changes or enhancements to their website or app. When developers rely on third-party plugins, making these customizations becomes pretty much impossible:

• Lack of Understanding: Developers might not be familiar with the plugin's internal code and you can’t edit code you don’t understand - that’s the way to completely break it.
• Design Mismatches: Plugins may not align with your project's specific design or user experience requirements.
• Inflexibility: Plugins themselves are contained solutions that creates, in context of entire project, artificial limitations.

4. Dependency on External Updates

If a plugin has a bug or becomes incompatible with other parts of your system, developers have to wait for the original plugin author to release an update. This can delay critical fixes and leave your system vulnerable or broken in the meantime. If the plugin developer didn’t discontinued work on it.

5. Unpredictable Future Incompatibilities

Plugins can become incompatible with new updates to browsers, operating systems, or other software components. This unpredictability means that what works today might not work tomorrow, causing maintenance headaches and additional costs. And yet again, it’s caused by developers not understanding what’s going on inside, which is difficult due to different code, methods and styles used in each plugin - reading a code is difficult even if it’s written by your internal documentation.

6. Missed Opportunities for Developer Growth

When developers create custom solutions:

• Skill Development: They enhance their skills and stay updated with the latest technologies.
• Better Solutions: They can create efficient, streamlined code tailored to your specific needs.
• Reusable Code Libraries: Developers can build a library of custom code that can be efficiently reused in future projects, benefiting you and other clients.

7. Enhanced Project Cohesion

Using custom code ensures that all components of your project are cohesive and compatible. This reduces the risk of errors caused by conflicting plugins and ensures that the user experience is seamless.

8. Cost-Effectiveness in the Long Run

While plugins might seem like a quick and cheap solution, the potential costs associated with security breaches, performance issues, and maintenance can far outweigh the initial savings. Investing in custom code can provide better value over time.

The Alternative: Custom Code and AI Assistance

Developers can leverage AI tools to assist in creating custom code, offering two major advantages:

• Simplicity and Clarity: AI-generated code can be straightforward and written in standard programming languages, making it easier to understand and maintain.
• Active Engagement: Developers must actively think about the code they're generating, setting clear goals and ensuring the intent behind the code aligns with your project requirements.

THE INTENT

That is exactly what is missing when using plugins. Developers settle for whatever is available.

If they look for a JavaScript gallery, the developers take first think they like, which is usually “it works with framework I use and is easy to set up”, but gallery in e-commerce product needs something very different than opening one big picture in blog articles.

The first thing to think of should be the opposite - “What do we need? Does something like this exist to be used?”.

Our Approach at LINK-V

At LINK-V, we prioritize writing custom code using standard programming languages. This approach allows us to:

• Maintain Control: We fully understand and control the codebase, making it easier to implement changes and optimizations as needed.
• Ensure Security and Performance: Custom code can be optimized for your specific project, enhancing security and performance.
• Offer Flexibility: We're able to say "Yes, we can change that" when you request modifications, ensuring your project evolves with your needs.

Our experience with both free and expensive plugins has shown us that custom code provides greater freedom and options, without locking us into third-party dependencies. It means that whatever is needed, we can ensure it and if time is important, we can do it quickly!

When Plugins Might Be Acceptable

I understand that in certain situations, such as projects with extremely tight budgets, using plugins might be a necessity.

Or maybe some short-term projects, like single-campaign landing page (although you may want to use no-code solution for that).

However, it's important to recognize the trade-offs involved and to approach such solutions with caution. Developers know about them and either accept it or, more often than not, ignore it. As a client, understand that development is expensive and if you need to a cheaper solution, it won’t be the best quality. Honestly, ask the developer where they expect to cut the cost.

Conclusion

Plugins are mostly bad idea. Especially today as developers can replace them with intentional work made by AI, that can write the entire code these days.

If you have a plugins developer that you know do a great job, is consistent, has a support and probably has paid products, sure, go for it, that’s a great cooperation. In all other cases, there are better ways to do what you need to do.