The demand for software engineers is higher than ever, and it grows by the day. Custom software provides immense benefits to businesses and their customers. It is a necessity for most businesses to keep up with the modern world.
If you've kept up with software progression over the years, you've probably noticed a pattern emerge where we repeatedly recreate the same things in different ways, often using different technologies, languages, tools, platforms, and paradigms. The primary reason for this repetition is that software (mostly) exists to fulfill human needs, and we've grown to expect certain functionality from the software that we use. We almost always log in. Sometimes we want to be notified. Businesses need to be paid, and the easier it is for customers to do that, the better. It takes significant amounts of time and effort to seamlessly integrate all of these things into the custom software that powers businesses.
It's impossible to know the exact percentage, but it's safe to say that at least 50% of software projects fail. Various sources report failure rates ranging from 25% to 80%. The common theme behind these failures is a lack of time. Developers everywhere routinely underestimate the amount of time it takes to build quality software. Much of the reason for this comes down to a lack of experience, unclear requirements, and/or factors beyond their control.
To be competitive in today's markets, you will need to integrate with third party services and platforms, each with their own sets of requirements and restrictions which evolve over time. You have no control over any of this. It can take a very surprising amount of time to properly integrate these systems.
Nowadays, we have a myriad of amazing libraries, tools, and services we can use to make development easier, but we still spend entirely too much time manually integrating them to produce the result that we really want, things that are actually functional and useful, complete with all of the integrated functionality that users have come to expect. Many example git repositories and app starter kits are generously available, but they are all very limited in what they do. They all still require a lot of work to turn into something that meets real world needs.
Are millions of developers really going to continue reimplementing the same integrations for systems and functionality that we know we need? I don't think so, but collectively, we're not quite there yet. We've refined our tools. Some systems and best practices have solidified. These things are not going anywhere for the forseeable future, so why not take the next step and reduce the time and cost of integration to almost nothing? This is the problem Molecule.dev aims to solve.
Our approach is based on tools and workflows already used on a daily basis by developers everywhere. The goal is to instantly produce the kind of output that teams would expect if they themselves implemented it over months (or years) for their specific stack and requirements. The result is something that developers have full control over, without the need to learn (or be locked into) some elaborate framework or wait on someone else to implement any extra functionality they need in the form of issues, forks, and pull requests. (Some functionality could certainly be packaged and installed as dependencies, but that is a discussion for a later date. Molecule.dev primarily provides the glue between all of your dependencies and integrated systems.)
99.9% of it is free and open source with an Apache 2.0 license, and there is a lot more in the works. Once we've made it even easier to add more options and integrations, it will be opened up to contributors. Long term, the goal is to provide a tool which skips all of the most boring and tedious system integrations, while combining all of the most popular tools and libraries, so that developers can focus on building what really matters.
Thanks for reading!