In HighSolutions the software development process is very complex and long, everyone taking part in it have to be as flexible as can be. We can divide this process into main parts which can give us a good overview of how this looks like. Of course not every step is needed in every project, for example, if clients need a chatbot on their Facebook fanpage, we can omit redundant design part, or when the client’s needs are really well-spoken in documentation - there’s no need for workshops.
- Software Development
The first part we will look at is an estimation part. This chunk happens even before any contract is signed with a client. It’s a time during a project where business meets the technical team. The tech leader responsible for a project needs to squeeze every drop of knowledge that business has about the client’s needs. Here is where we decide which technology we will use.
Sometimes the team needs to meet with a client to discuss their detailed needs. With this step, we can avoid future issues. Often the client doesn’t have a full picture of his product and didn’t think about some technical issues that software developers will see instantly.
Also meeting with a client face to face allows us to build a stronger relation, which helps in future contact when there are any misunderstandings.
During the planning part of a whole process team leader writes down every part of the project into smaller, simpler tasks. In a perfect project, they should be simple enough, that they could be taken out of context and made by any developer without knowledge of the whole. Firstly project is broke into larger pieces called “milestones” which are basically sets of functions of an app. Then we start thinking about how a user is going to interact with these functions, and create smaller chunks that we call “user stories”. Then inside these user stories we write down actual tasks for developers with as many details as we can.
Now it’s the time for our design team to step in. Most often technical leader prepares a list of views our app should have and based on those pieces of information they prepare wireframes.
Wireframes are “sketches” of application, which can be done very quickly, but they say a lot about how the final product will look, what features it will have and how different parts of the system will interact with each other. They are consulted with developers to check if all designed features are possible to implement.
If wireframes are accepted both by a client and developers team, designers begin their work on actual designs. They contain every detail of a product more information like a color palette used in a project, real content, images that will be shown on the website. They are used as a model for developers on how exactly the app should look like pixel by pixel.
And for the last step, we create prototypes. Due to them the client can “use” an app without any code written. They are basically designed with clickable parts to take you from one view to another. It allows the client to get used to how the app will be used as a final product.
Here is where the actual magic happens. Developers take their small tasks and slowly creates a bigger thing. In the meantime, automatic tests are created. They assure us that code does what it should do even when big changes are made. To allow developers to work simultaneously on one code base we use version control solutions, where all changes are stored, and then we can combine them into the final product.
Developers also create different environments for an app to live in. We may need separate instances for developers, testers, and clients to keep up with the newest changes, and when everything is fine all approved features end up on a production server where actual users can use it.
Developers are still humans (even though sometimes they don’t act like ones 🤖), so they don’t create perfect software. Automatic tests help during the process, but they can create false convictions of our perfection. This is where other humans step in. Testers firstly give our app a fair round - they use it as users are supposed to. They didn’t do anything special, just check if everything works as it should. Then if they can’t find anything, special steps are taken. Every part of a project is tested to its limit. Testers use such brutal techniques as writing nonsense into every field, spam clicking buttons or even looking into developers console to look for any errors.
Generally, a tester finds a bug and reports it to a developer, but there are many other cases. For example, if developers realize that some features will take too long to code it goes back to the design phase where it can be done a different way.
That is why software development is never a straight path as you can imagine. It is rather a cycle in which each part of the task can be taken back to the step.