Software Development Methods

From OpenCommons
Jump to navigation Jump to search

Sectors Data
Contact Wilfred Pinfold


Choosing between proprietary software and open source software for municipal services software development depends on several factors, including budget, functionality requirements, security, and long-term sustainability.

Proprietary software can provide a more comprehensive and fully-featured solution but comes with licensing costs that may not fit within a municipality's budget. Additionally, proprietary software typically requires vendor support, which can add additional costs and create dependency on a single vendor. This vendor lock-in can limit the municipality's ability to modify or improve the software as needed in the future.

On the other hand, open source software can provide cost savings and flexibility for municipalities. The open source community allows for collaboration and contributions from multiple stakeholders, which can lead to faster and more frequent updates and improvements. Open source software is also customizable and modifiable, allowing municipalities to tailor the software to their specific needs.

Overall, a municipality should consider the trade-offs between proprietary and open source software when making a decision. If cost is a significant concern, open source software may be a more viable option. If a comprehensive and fully-featured solution is necessary, proprietary software may be the best choice. Ultimately, the municipality should carefully evaluate the software options and choose the one that best fits its requirements and long-term sustainability goals.

Proprietary software

Proprietary software development creates lock-in by limiting the ability of government agencies to modify or adapt the software to their specific needs, as they are often bound by strict licensing agreements and vendor restrictions. This can lead to a situation where agencies are dependent on a single vendor or technology, with limited options for switching to other solutions, even if better or more cost-effective alternatives become available.

Reduced maintainability is a common problem with proprietary software, as the source code is typically not available for review or modification by the agency or other third parties. This can result in a situation where the vendor holds the keys to the software, making it difficult or even impossible for the agency to fix bugs, add new features, or integrate with other systems without vendor assistance. This dependency on a single vendor can increase costs, as agencies may be charged high fees for maintenance, updates, and support services.

In addition to reduced maintainability, proprietary software development can result in failed procurement due to a lack of transparency and competition. Without access to the source code, agencies are unable to fully evaluate the software's quality, security, or fitness for their needs. This can lead to situations where agencies are stuck with software that does not meet their requirements, is vulnerable to security threats, or is difficult to use.

Moreover, proprietary software often comes with licensing fees and other costs that are not transparent, which can make it challenging for agencies to budget effectively. As a result, they may find themselves locked into long-term contracts that are difficult to break, even if the software does not meet their needs. This can create significant financial burdens for government agencies, which may result in reduced funding for other critical programs.

In contrast, open source software development provides agencies with more flexibility, transparency, and control over the software they use. With access to the source code, agencies can modify the software to meet their specific needs, integrate it with other systems, and fix bugs or security vulnerabilities as needed. Additionally, open source software is often more cost-effective, as there are no licensing fees or other hidden costs.

Overall, the use of proprietary software in government procurement can create significant risks and costs, while limiting the ability of agencies to adapt to changing needs and technologies. Open source software provides a more transparent, flexible, and cost-effective alternative that can help government agencies deliver better services to citizens.


There is some evidence to suggest that the use of proprietary software by government can contribute to project failures. A 2018 study by the Standish Group chaos2018, which analyzed 50,000 software projects, found that only 29% of proprietary software projects were successful, compared to 42% of open source software projects.

One reason for this discrepancy could be that proprietary software often comes with a high price tag, which can lead to cost overruns and budget issues. Additionally, proprietary software is often less flexible than open source alternatives, which can make it difficult to customize and maintain over time.

Another issue with proprietary software is that it may not be compatible with other systems or technologies used by the government, which can lead to integration issues and additional costs.

It's important to note, however, that project failures can have many causes, and the choice of software is just one factor that can contribute to success or failure. Other factors, such as project management, stakeholder engagement, and technical expertise, also play a significant role.