Getting trust back in your software
Smartfile already had valuable software, but its technical foundation made further development difficult. Together we improved the codebase, tests, and deployment process so the team could add new features with more confidence.
Client
- Industry
- Healthcare
- Location
- Utrecht
Team
[Smartfile](https://www.Smartfile.nl/) offers physiotherapists a complete software package with an abundance of features. You manage customer files with it, organize patient records, schedule appointments, and also handle the administration. A robust whole that covers virtually every aspect of practice management.
The situation
A product that worked, but had become too fragile
Smartfile kept expanding its application in response to market demand. The number of features grew while the underlying technology became less reliable. Adding new features in particular increased the risk of errors.
And that does not only hit the developers. When software processes sensitive data, a lack of trust becomes a direct business risk. The fear that a small change breaks something or leaks data brakes every next step you need to take in order to grow.
At Smartfile, access to patient records was a particular concern. An Glossary · In briefauthorizationAuthorization is the process of determining and enforcing which data and functions a user, device or application may access.Read more error could allow a practitioner to see records they should not have access to. Concerns about such errors made the team hesitant to expand the application.
The question behind the question
A reliable foundation for new features
Smartfile asked for help adding features. First, authorization, tests, and the Glossary · In briefreleaseA release is an identifiable software version prepared to be made available to users. It brings together one or more checked changes.Read more process needed improvement so the team could make changes with more confidence.
Approach
Laying the foundation again
The application's technical foundation was rewritten. The authorization system denies access to data by default, unless the user has explicit permission. This reduces the risk of unintended access to patient records. With this foundation, Smartfile's development team can add new features with more confidence.
Every time new code is added you have to test the whole software again, an intensive, time-consuming job, so we switched to automated tests. To get that done we first needed to map what functionality was in there. When Smartfile builds something new in the future, the server immediately runs all those automatic tests.
We also tackled the rollout process and automated it extensively. With a standard Glossary · In briefdeploymentA deployment is the process of installing and starting a chosen software version in a target environment so it can be tested or used there.Read more you quickly go through about eight steps in a fixed order. Automation puts software online within a few minutes. With a second environment you can deploy with zero Glossary · In briefdowntimeDowntime is the period when software, a system or an online service is unavailable or its essential functions cannot be used.Read more and Glossary · In briefrollbackA rollback reverses a change so software, configuration or data returns to an earlier state. Teams use it when a change causes errors or other unwanted effects.Read more immediately if something goes wrong.
What we add
A stable foundation With a strong authorization basis there is less chance of errors around access to sensitive patient information.
Automated tests Every code change triggers tests, so you see faster what a change unlocks and need less manual checking.
Automated deployment Fewer manual steps, less error risk in the release process, and the ability to roll back.
Quality and continuity
Releases you can trust
Tests and automated deployment make releases more predictable. The team can check and deliver changes through a consistent process, with fewer manual steps.
Result
Ready to build again
The foundation came into order, testing and deployment were overhauled, and adding new functionality became workable again. The application sat more stably, the development pace picked up, and Smartfile got the safe basis back to build forward.
The team needed to be able to make changes with confidence in how the application handled patient data.
Key takeaways
Trust in your own software is a hard precondition for growth, especially with patient data.
Authorization works better when you grant rights explicitly, instead of implicitly opening everything.
Tests and automated deployment make releases predictable and take away fear around going live.
OUR WORK
