Discover more from Software Whisper
The Basics of Creating Valuable Software
Creating working software faster and cheaper while meeting and exceeding users' expectations.
Hi there, it’s Niels. 🤗 Welcome to my bi-weekly newsletter. I started this newsletter to help businesses with maximizing their impact and improve job satisfaction for their workforce. The newsletter helps with the creation of valuable digital solutions, making better digital investments, and creating an efficient organization. Questions? Ask them here.
During the creation and delivery of software, businesses often focus on the features of their product. Customers on the other hand are looking for solutions and how that particular solution will improve their life.
I really like how the people from UserOnboard showcase the relationship between the product a business produces and the customer looking for a solution.
People don't buy products. They buy better versions of themselves.
When you're trying to win customers, are you listing the attributes of the flower or describing how awesome it is to throw fireballs?
It’s not because you buy a product that it will completely fit your needs. Very often customization or extension of the product is required. Often the product is only a (small) part of the complete solution the customer needs.
To be or stay successful, businesses that are building solutions have to constantly look for ways to reduce costs, deliver working software faster, and meet or exceed their user’s needs.
But also, I’ve been part of projects or product teams where:
we built solutions no one wanted or did not meet the needs
we delivered slowly and introduced bugs frequently
the cost of creating solutions was higher than it should be
In this article, I will talk about the software development process, the people doing the work, and the kind of technologies that are used. The information can be used as a high-level blueprint for which the different parts can be adjusted to your specific needs.
Why Is This So Hard?
The number of different technologies for creating software is rising. The amount of highly skilled engineers that can work with advanced technologies is small. Skilled software engineers seem to prefer to work in high-tech environments instead of building domain-specific solutions that are less complex in terms of technology. The total group of traditional software engineers is too small for the increasing demand for digital solutions by businesses.
An enormous amount of low-code and no-code tools for creating software are already available. These tools are aimed at less skilled developers. It’s often not very clear what’s possible with these tools and what skills are necessary to effectively use these tools.
Under certain circumstances, it will make sense to opt for a no-code or low-code strategy for building a solution. Sometimes due to the complexity of the project, custom high-code written by skilled software engineers will be needed. And sometimes a combination of strategies is the best choice.
Businesses often rush to solutions and technologies for building software too quickly. They are usually sold on the sole idea that developing software needs less skilled resources and won’t take a lot of time.
Creating software is not only about writing code or drag-and-dropping components.
The chosen development strategy sometimes lacks quantitative and qualitative support. This increases the risk of a bad outcome for the customer (internal or external), the business, or both.
Bad choices are most often a people problem while all the technology is working fine. The tech just doesn’t fit your needs.
Creating Software Solutions
Businesses are constantly looking to improve the process of creating and delivering working software. This means:
improving the speed of delivery
meeting and exceeding customer’s needs
The smoother the process runs, the better the above goals can be achieved.
The process of creating a software solution always includes people and technology. A software solution is equal to the process outcome of how people are working with each other and interacting with technology.
Solution = Process (People + Technology)
The (SDLC) Process
The software development life cycle (SDLC) is a process that helps to quickly develop high-quality software ready for production. When researching this process, diverse sources mention different steps. The number of steps is always somewhere between 5 and 8.
I personally like the steps shown in the picture below. No matter if you choose an Agile or Waterfall approach of the SDLC, all these steps are important and they all deserve enough attention. Choosing the best SDLC implementation is dependent on many things. Some of them are the needs and complexity of the project and the business.
A project should always include a vision and a direction of the envisioned solution over time.
The first phase is about crystalizing the problems that need to be solved. It’s also essential to:
have a deep knowledge of your target audience.
look at the alternatives your target audience has including what competitors are offering.
A good strategy and clear goals will create focus, clarity, and alignment for all people involved in the initiative.
If you get this phase completely wrong, you will end up building software that no one wants (bad enough) and will not be used (enough). All the effort put into the next steps will be a complete waste of time and money.
The design phase is about clarifying technical and functional requirements.
Technical requirements include:
a description of the software quality attributes the solution needs to have. Some examples are maintainability, reusability, security, and scalability.
a high-level architecture and what important building blocks are needed. Examples of building blocks are:
Programming Languages (Java, C#, Python, …)
Products (SaaS, Open Source, Databases, Deployment Environments, Low-Code, No-Code…)
An end-solution is comprised of many different products, custom development, and integrations.
Functional requirements are about what needs to be implemented so that the users of the solution can achieve their goals. Prototypes are often built to better understand what the end solution should look like and how it should behave.
During this phase, the software engineering team builds the necessary features that are in scope using the chosen technologies.
There are multiple ways for building features:
In high-code environments, the features are built by writing code.
In no-code environments, building features happens by configuring pre-built components.
Low-code development is a mix of high-code and no-code.
This vital phase tests the software to ensure everything works as expected. Defects are fixed when they are discovered.
Three important types of testing exist:
Unit tests test individual components of an application in isolation (without any interaction with dependencies) to confirm that the code is doing things right.
Integration tests check if different components are working fine together. Real dependencies are used.
Functional tests test a slice of functionality in the system to confirm that the code is doing the right things. Functional tests often have dependencies.
Software deployment includes all processes that ensure a software system or update is available to the users. Usually, this includes software release, installation, testing, deployment, and performance monitoring.
Often different environments are required. You need at the very least 2 depending on the kind of platform that you are using and the complexity and needs of the solution.
Deployment pipelines enable versioned artifacts to be pushed to higher environments. It’s also beneficial that rollbacks to previous versions can happen easily.
The lifetime of the solution is not at its end once the solution is deployed. It’s called the software development life cycle for a reason.
In this phase, the development team processes feedback and fixes bugs discovered by users or stakeholders, and provides ongoing enhancements. It’s often crucial that the end solution can be easily customized when changes are needed.
Make sure that enough people have the necessary knowledge and skill to maintain the solution.
People And Technology
People should always have the required skills to work with a specific technology. You can hire professionals that are specialized in that technology or you can train people so that they acquire those skills on the job. It often happens that training is underestimated.
Creating a website is much easier than it used to be. Unless you need something very specific with complex integrations and an advanced user interface, most people can already do this by themself.
Not so long ago, access to people with advanced skills was a prerequisite to building a website. You needed to have a deeper knowledge of user interface design, front-end and back-end programming, databases, networking, and infrastructure.
Nowadays, there are SaaS solutions where non-technical people can start from a template based on the goal of their website. All they have to do is tweak it a little bit by configuration instead of programming.
Everything is hosted and managed by the vendor. It’s robust, scales automatically, it’s secure, and it’s also cheap. Your job is to focus on the content for your site and the message that you would like to send. And even there, the templates are helpful for providing ideas.
These SaaS solutions have free versions which often suffice to start from. You can easily upgrade to a premium version when you need more advanced features to accomplish what you want. Even those premium versions are ridiculously cheap compared to the early days of building websites.
This story is a simple example of the democratization of technology.
Democratization of Technology
The democratization of technology means that over time more people have access to specialized knowledge without the need for extensive training.
Building things with new technologies entering a market cost a lot of time and money. The volume of things created with the technology is relatively small and the rate at which they’re made is small.
Over time, the technology advances and gets packaged in ways that require less expertise in the technology itself. It gets easier to apply the technology in the context of a particular domain. People need less advanced skills to take advantage of the technology.
The cost of creating things with the technology drops. The volume of things created and the rate at which they’re created rises.
Stages of Technology Democratization
This paper shows that there are five stages that technology goes through as it is being democratized. The stages can be identified by different groups of people.
Discipline Experts: Tech professionals who are primarily masters of the core technology, independent of the domain in which it is applied. Often small tech-savvy startups are deploying sophisticated forms of technology.
Domain Experts: Tech professionals who master the technology in a particular domain, e.g., marketing technologists who build solutions within the marketing department.
Power Users: Non-tech professionals who develop advanced technical skills in leveraging the technology, e.g., tech-savvy marketing automation platform administrators.
Users: Non-tech professionals, people who are not experts in a particular discipline, can use tools to accomplish tasks in those disciplines. For example, new technological tools enable non-IT experts to build websites themselves.
Ambient/Automatic: Technology just works within the domain without users needing to explicitly manage/operate it, e.g., where automation or AI simply take over the work.
Democratization of Software Development
Developing software is part of the democratization of technology. That’s also why we hear the term citizen developer a lot nowadays. Citizen developers are not professional developers but rather tech-savvy domain experts.
People with advanced skills are becoming more scarce. The demand for professional skilled developers is enormous at the moment. Due to the democratization of technology, more people with limited skills can participate in the process of building software solutions.
Software engineers will never become redundant. They will need to build the development platforms and tooling so that less skilled users can create software solutions.
When building a solution, it’s important to focus on the benefits for the end-user instead of focusing on the features of a product. Building solutions that don’t meet the user’s needs is just a waste of time and money.
The Software Development Life Cycle process is an abstract and circular process that consists of multiple steps. There are many ways to implement it. All the different implementations need to take into account the following steps: strategy, design, development, testing, deployment, and maintenance. Choosing the best implementation of the SDLC process is dependent on many factors. These include the complexity and the needs project, and the business.
The process of creating a software solution always includes people and technology. People should always have the required skills to work with a specific technology. Software development is part of the democratization of technology. The democratization of technology means that over time more people have access to specialized knowledge without the need for extensive training.
There will always be a need for software engineers. They will enable software solution building for less skilled users.
At Sirris, we help you make better digital investments:
We provide vendor-neutral guidance on how you can build valuable digital solutions and products.
We focus on people and processes and never look at technology in isolation.
Schedule a free conversation now if you want to maximize the impact of your digital initiative.
Thanks for reading Venture Whisper! Subscribe for free to receive new posts and support my work.