We break down scope in bite size chunks, and deliver these new features every cycle. A typical development cycle (or sprint) is one to two weeks. Since the latest version of the software will be available as soon as developers check-in, you can provide feedback as soon as minutes after the last update.

Our teams are equipped with all roles required to deliver successful software. A typical team consists of Experience Design Engineers (UI/UX), Software Engineers, Quality Assurance Engineers, Project Management, Solution Architects and CTO hours where necessary.

Software requirements always leave a lot of room for interpretation. At You_Source we cover most of these by our DoD (Definition of done). This not only improves the process but also speeds up the development cycles. The DoD covers topics from user experience to coding standards and from the security to process.

We like to demo what we have as often as we can, as this helps us iterate and improve on the solution. After every development cycle we have a demo. We will ask you for feedback and apply that as soon as the next development cycle.

All our projects are unit tested to a coverage of at least 80%. These tests are automatically run when a developer submits new code. When any test fails, the code will be rejected and requires the developer to fix any mistakes or merging issues so that the source code will only contain running and tested code.

Application Lifecycle Management is crucial to the overall success of a software development project. We manage this lifecycle in the most applicable tools for your project, using tools like Azure DevOps, Slack, Jira and others. We are fully transparent using these tools and you have access to your source code, requirements and infrastructure from day 1.

We invest early on in a 3 stage environment that gives you full visibility in the progress of your project or team. The development environment contains the latest features, the staging environment the latest features ready for testing, and these get pushed to production when approved.

Software development contains a lot of problems that are usually solved with similar patterns, that work on code, architectural or infrastructure level. We have established a set of patterns that solves most software engineering problems and we train our developers to understand, build and maintain these patterns. This improves overall maintainability and helps developers build structured code in a familiar fashion, allowing them to be more productive and deliver software that they can be proud of.

Backend code will always be unit-tested to a minimum of 80% coverage. Unit tests can be executed fast and often, and gives the developer the confidence that his changes or contributions did not break any dependencies. We also measure the maintainability index, which ensures that the code is of readable complexity.

Security is non-negotiable, and is hard to define using just requirements. We have a standard set of security requirements that we implement in all projects which covers the requirements set by law. We are also skilled at going that extra mile to deliver applications where we as developers of the application would not even have access to the data involved.

Static code analysis is leveraged both on the developer machine as well as during the check-in process. When a developer submits his code to the code repository, the system will run an automated code review, and when warnings or errors are found, the code will be rejected. This keeps your source code consistent with standards and helps keeping the code clean, even when the deadline comes close.

In development more often than not the user is completely overlooked. Systems are designed by committee and not for a good User Experience. We help you through the process of converting your ideas in the usable User Experiences. We do this with the help of rapid Prototyping and by making interaction designs. We test those and make implementation plans based of them. While implementing we expose the results as early as possible to user through user testing. Iterating often gives great results with minimal efforts.

When we design systems or part thereof, we keep a strong focus on the architecture and scalability. In principle we design all components fore the cloud that are easily and highly scalable. Where we make concessions, we do this while keeping you informed.

When we develop software, we get quick/interim results to you by developing the frontend fist. We do this because when the frontend starts to become real better feedback and real-world testing and validation can be done. This early feedback will save a lot of time in development because changes at that stage only have effect on the frontend and not the backend since that will simple not be working yet.

Most of our architectural designs are based on a microservice concept ore a slight variation thereof. Making a system out of small components working together create a lot of advantages like, easier scalability, mixing and matching of technologies, improves testability, easier fault isolation and much better reusability.

Seeing is believing, we like to show what we got as often as we can. We iterate quick and often. After every development cycle we have a demo, sometimes only internal but most often you will be included. We will ask you for specific feedback and apply that in the next iterations.