MLOps vs. DevOps Explained

MLOps vs. DevOps Explained

Although the juxtaposition of MLOps vs. DevOps may seem robust, these approaches can collaborate efficiently to optimize development processes. 

DevOps, a compound of development and operations, emerged as a cultural and professional movement advocating for the automation and integration of software development and IT operations. Its fundamental philosophy centers on collaboration, automation, continuous integration, and continuous delivery, with the goal of reducing the systems development life cycle duration while maintaining high-quality software delivery.

As DevOps evolved, it led to several specialized fields like AIOps, MLOps, DataOps, and DevSecOps. Each variation adapts the core principles of DevOps to specific areas, streamlining and enhancing those domains.

DevOps continues to influence many areas, including cloud computing, big data, and more, demonstrating its adaptability and importance in new and developing technology.

Understanding MLOps

MLOps, or machine learning operations, is a practice that brings together machine learning, data science, and operations. It aims to automate and improve the end-to-end machine learning lifecycle, from data preparation to model training, deployment, monitoring, and maintenance.

devops and machine learning

MLOps vs. AIOps vs. DataOps

MLOps, AIOps, and DataOps are crucial methodologies, each with distinct focuses on managing data and taking advantage of automation. Let’s explore how these methodologies differ in terms of their pipelines.

MLOps revolves around optimizing the lifecycle management of machine learning models, spanning from development to deployment and ongoing monitoring. Its pipeline typically includes:

  • Data acquisition and preparation
  • Model development and training
  • Model evaluation and validation
  • Model deployment
  • Monitoring and support

AIOps use AI and machine learning to make operations faster, automate tasks, and improve system performance. Its pipeline encompasses:

  • Data ingestion and processing
  • Anomaly detection and root cause analysis
  • Incident response and automation
  • Continuous improvement and optimization

DataOps emphasizes collaboration, automation, and agility in managing data pipelines and workflows, focusing on accelerating insights delivery. Its pipeline comprises these stages:

  • Data integration and ingestion
  • Data preparation and quality assurance
  • Model development and deployment
  • Collaboration and governance
  • Continuous integration and delivery

So, in essence, while MLOps specializes in managing machine learning models, AIOps focuses on enhancing operations through AI-driven insights, and DataOps emphasizes collaboration and automation in data management. Each methodology’s pipeline reflects its unique role in optimizing specific aspects of data-driven operations in the complex digital space.

How DevOps, AIOps, MLOps, and DataOps work together

These practices complement each other. For instance, AIOps, or DevOps and artificial intelligence, can enhance MLOps by providing advanced analytics to optimize machine learning models, while MLOps can benefit DataOps by maintaining data quality and accessibility for machine learning projects.

How businesses use MLOps and what benefits they get

Machine learning in DevOps significantly refines the lifecycle of machine learning models. By automating processes and promoting collaboration among data scientists, engineers, and business stakeholders, MLOps enhances the efficiency of developing, deploying, and maintaining ML models.

For example, McKinsey reported that an Asian financial services company reduced the time to develop new AI applications by more than 50% by implementing a common data-model layer and standardizing data-management tooling and processes.

MLOps also preserves the quality and reliability of machine learning models by consolidating and automating processes. This approach reduces errors and makes sure that models perform as expected in real-world environments, such as tackling fraud risks in banking. MLOps enhances model auditability and responsiveness to change and provides a methodology for combining rapid feedback with automated monitoring to maintain model accuracy over time.

Companies using comprehensive MLOps practices shelve 30% fewer models and improve their AI model value by up to 60% (McKinsey).

As for people, MLOps frameworks empower data scientists by automating routine processes and allowing them to focus on higher-value tasks like adding new features to existing models and solving other business challenges.

MLOps optimizes costs and resources by improving model performance and polishing operational processes. By taking advantage of MLOps, organizations can manage machine learning consumption costs more effectively, ensuring resource-heavy analytics solutions are designed with cost considerations in mind.

Overall, implementing machine learning in DevOps delivers substantial business results, including cost savings, productivity gains, faster innovation, and improved model reliability. These examples and statistics demonstrate the transformative impact MLOps can have across different industries.

See how Timspark harnessed MLOps in Banking

machine learning in banking

Challenges of implementing MLOps solutions

Stakeholders sometimes view AI for DevOps as a miraculous solution for all issues, setting unfeasible goals, especially when non-technical stakeholders are involved. However, it doesn’t stop here. Take a minute to review the most common DevOps and machine learning implementation challenges and how to tackle them effectively.

Challenge

Solutions

Unrealistic expectations

- Set clear, realistic goals and expectations with all stakeholders.
- Educate non-technical stakeholders on the feasibility and limitations of AI solutions.

Data management

- Centralize data storage and implement shared mappings across teams.
- Efficient data versioning and keeping data updated, especially for time-sensitive solutions.

Security

- Adopt software that provides security patching and support.
- Employ multi-tenancy technology for data privacy and protection of internal environments.

Inefficient tools and infrastructure

- Seek budgets for virtual hardware subscriptions like AWS or IBM Bluemix.
- Transition from notebooks to standard modular code for more efficient algorithm development.

Lack of communication and user engagement

- Engage with users early in the process.
- Regularly demonstrate and explain model results and allow feedback during model iteration.

Technical and operational issues

- Develop expertise in Kubernetes and containerization.
- Automate deployment pipelines and adapt to data growth with scalable resources.

Using machine learning inappropriately

Evaluate the need for an ML solution; consider simpler, rule-based systems when appropriate.

Integration with business systems

- Consider the downstream application of ML models at the start.
- Check if ML models are technically compatible with business systems and deliver expected accuracy.

Feature management and operational challenges

- Use scalable and production-ready data-science platforms from day one.
- Adopt automation and higher-level abstractions.
- Focus on collaboration and re-use in MLOps practices.

At Timspark, we guide organizations through these challenges, offering tailored solutions that align with business objectives and technical requirements.

We help:

  • Set realistic goals
  • Improve data management
  • Enhance security
  • Upgrade tools and infrastructure
  • Facilitate better communication and user engagement
  • Provide technical and operational support
  • Ensure the appropriate use of ML
  • Integrate ML models with business systems

Consider MLOps in pursuit of competitive advantage

The incorporation of DevOps methodologies into AI and machine learning represents more than just a passing trend; it’s an essential progression to meet the growing complexity and demands of technology. The implementation of machine learning in DevOps and its associated practices offers businesses the opportunity to achieve greater efficiency, innovation, and competitive edge. As technology advances, the application of these principles will also evolve, heralding promising advancements in the future.

Should you be considering the integration of DevOps and machine learning into your workflows but find yourself facing one or more challenges, don’t hesitate to get in touch and seek comprehensive support throughout the process.

Turn to Timspark to enhance your business with DevOps

Cracking the Code of Cross-Platform Development: Challenges and Advantages in a Nutshell

Cracking the Code of Cross-Platform Development: Challenges and Advantages in a Nutshell

The beginning of the 21st century witnessed an explosive surge in high-tech advancements, making Internet services and mobile apps an integral part of daily life for people of all ages. While this presents a positive trend for software developers with an expanding user base, it comes with its challenges. The number and variety of platforms that need to be supported has increased significantly. Failure to support this diversity results in not reaching the target users properly.

According to the StatCounter service, more than 40% of users access the Internet from Android devices, just under 30% from the Windows operating system, approximately 18% and 7% are users of iOS and MacOS devices, respectively, and the share of Linux users is also growing (statistics for 2023, WorldWide region).

 

Source: StatCounter Global Stats – OS Market Share


Creating and maintaining a product for various platforms with distinct code bases can be a constant headache for manufacturers. That’s where cross-platform development comes in.

The most promising cross-platform app frameworks

By the time we write this article, various statistical aggregators named .NET MAUI (Xamarin), React Native and Flutter as  top-choice frameworks for cross-platform development. Additionally, we are including Kotlin Multiplatform to this list. Wondering why? Let’s delve into the details below.

.NET MAUI (Xamarin)

Xamarin, released in 2011, emerged as one of the first successful open source technologies for cross platform mobile development. Later acquired by Microsoft, Xamarin received investments and saw its robust features integrated into the .NET platform. The result of this symbiosis was .NET MAUI, representing the next evolutionary step for Xamarin. Meanwhile, official support for the original Xamarin framework is scheduled to end on May 1, 2024.

.NET MAUI (Xamarin) pros:

  • The framework is based on .NET, the programming language is C#. According to a Stack Overflow Developer Survey, C# was named a popular language by nearly a third of professional developers
  • Officially supported platforms: Android, iOS, MacOS, Windows. WhileLinux is not officially supported, developers can create a Xamarin app for Linux using a workaround suggested by the developer community.

.NET MAUI (Xamarin) cons:

  • During the transition from Xamarin to .NET MAUI, Microsoft has shifted its focus from tvOS, Android TV and Apple watchOS. So, if you need to write an app for these platforms, you will have to look for another technology.
  • Since .NET MAUI apps operate through the Mono-framework (i.e. they have middleware to run the build on the target platform), their performance may lag behind that of native applications.
  • .NET MAUI is actually a superstructure of native components, so customization of the UI is limited.

    The architecture of the .NET MAUI app looks like this:
NET MAUI app architecture

The app code primarily interacts with the .NET MAUI API (1), which in turn directly consumes the platform’s native APIs (3). In addition, app code can directly invoke the platform API (2) if necessary.

Sample of “Hello World” application, created in .NET MAUI

.Net MAUI code example

React Native

React Native was released in 2015 by Meta Platforms, Inc. and initially intended for multiplatform mobile app development, that is, creating apps for both iOS and Android on a shared code base. Its programming language is JavaScript, which makes React Native especially popular among front-end developers.

React Native pros:

  • The programming language is JavaScript, which is the most widely used language in the world according to a Stack Overflow Developer Survey.
  • It is backed by a wide community and a large number of third-party libraries.
  • It uses a proprietary engine to render the UI, which allows you to create truly unique widgets and layouts without being tied to a predefined set of native UI components.

Officially supported platforms: iOS and Android. However, through collaboration with partners and the React Native community, it is possible to support MacOS Desktop, Windows Desktop, and the Web as well

React Native cons:

  • React Native remains in beta, which affects its stability. Its architecture and libraries change frequently, posing challenges for maintaining existing projects.
  • Operating on a bridge architecture, React Native has an intermediate layer to provide interaction between the React Native app and the target platform. This results in decreased performance and lack of flexibility.

Briefly, React Native architecture is shown below:

React Native architecture


Here is a sample of “Hello World” application, created in React Native:

React native code example

Flutter

In 2017, Google introduced Flutter, a framework for cross platform app development, with Dart (C-style syntax) as the programming language. While Dart may not be the most widely used language among software developers, it is relatively easy to learn. What sets Flutter apart are its proprietary rendering engines that allow you to create any custom widgets and UI layouts. Also, Flutter compiles assemblies into native machine code, ensuring the performance of Flutter apps is comparable to that of native apps.

Flutter pros:

  • Flutter does not rely on target platform widgets; instead, it uses its own rendering engine. This allows software developers to implement the desired UI without worrying about updates on the target platforms affecting the application’s appearance.
  • Flutter doesn’t use middleware to run its builds; instead, it allows direct assembly compilation for a specific platform, providing performance comparable to native technologies.
  • Officially supported platforms: Android, iOS, Web, Linux (Debian, Ubuntu), MacOS, Windows. 

Flutter cons:

  • You can only write a client app in Flutter. While Dart can be used with limitations for server-side development, it is not fully mature for this purpose.
  • You can’t invoke native APIs directly from Dart. You will have to use native languages to interact with certain APIs, such as:
    • Kotlin or Java on Android
    • Swift or Objective-C on iOS
    • C++ on Windows
    • Objective-C on macOS
    • C on Linux

Flutter has layered architecture, where each part of the framework layer is designed to be optional and replaceable:

Flutter architecture

Here is a sample of “Hello World” application in Flutter:

Flutter code example

Kotlin Multiplatform

Entering the scene as a fairly new player in the arena, Kotlin Mutiplatform is worth being added to the list. The Kotlin language, renowned among Android and backend developers for a long time, has gained a significant share, with approximately 95% of the top 1000 applications in the Play Store being written in it according to Google statistics. Therefore, it is not surprising that JetBrains decided to take Kotlin to the next level by adding support for various platforms. The beta version of Kotlin Mutiplatform was presented in 2022, and by the end of 2023 JetBrains announced its full-fledged release.

Kotlin Multiplatform pros:

  • You can use Kotlin not only for the client app, but also for the server-side development.
  • You can implement shared logic below the UI layer.
  • Developers have unrestricted, direct access to both Android and iOS SDKs.
  • With Compose Multiplatform (additional technology from JetBrains), developers can reuse UI code across platforms. However, Compose Multiplatform is currently only stable for Android and desktop.
  • Beyond the virtual machine option (JVM), Kotlin Multiplatform allows compilation of native binaries using Kotlin/Native ensuring no loss in performance.
  • Officially supported platforms: Android, iOS (Alpha), MacOS, Linux, Windows, Web Wasm (Alpha).

Kotlin Multiplatform pros:

  • Unlike the three cross-platform app frameworks discussed above, Kotlin Multiplatform does not support hot reloading, which affects the speed of software development and debugging.

Since Compose Multiplatform, which is required for sharing UI code, is still in alpha for iOS and web, Kotlin Multiplatform cannot be used as a full-fledged alternative to Flutter at this point.

High-level Kotlin architecture is shown below:

Kotlin Multiplatform

Here is a sample of “Hello World” application in Kotlin:

Kotlin code example

Cross-platform app development frameworks comparison

Criteria

MAUI (Xamarin)

ReactNative

Flutter

Kotlin Multiplatform

Current version

8

0.73 (still in beta)

3.16

1.9.22

Initial release

2022

(Xamarin itself was released in 2011)

2015

2017

2022

(Kotlin itself was released in 2011)

Manufacturer (Owner)

Microsoft

Meta Platforms, Inc.

Google

JetBrains

Programming language

C#

JavaScript

Dart

Kotlin

Hot reloading support

Yes

Yes

Yes

No

iOS support

Yes

Yes, incl. tvOS

Yes

Alpha ( incl. tvOS and watchOS), expected to be in Beta in 2024

Android support

Yes

Yes, incl AndroidTV

Yes

Yes, incl. Android NDK

Web support

No

Supported by community

Yes

Alpha

MacOS support

Yes

Supported by community

Yes

Yes

Windows support

Yes

Supported by community

Yes

Yes

Linux support

Workaround provided by community

Very limited, Supported by community

Yes

Yes

Ability to write server app

No

No

Dart can be used with restrictions

Yes

UI and its customization

UI elements are based on native component set, their customization is very limited

Uses its own engine to render UI. However, customization of the user interface is quite limited and poorly documented.

Uses its own engine to render widgets. The appearance of the application does not depend on the operating system version, so updates to the target platform will not affect it. The UI is highly customizable

You have the flexibility to utilize either your custom-designed UI components or integrate native ones. When using your own widgets,customization comes with minimal restrictions, and updates to the target platform will not affect the overall appearance of the application.

Performance

Degraded performance since .NET MAUI is a superstructure to native SDK and UI.

Due to the bridged architecture, performance may have some issues.

Performance is similar to the one in native apps thanks to compiling the application into platform-specific binary code.

Performance is similar to the one in native apps thanks to compiling the application into platform-specific binary code.

Framework stability

Generally stable. Sometimes the framework lags behind critical updates to target platforms, but Microsoft addresses these issues swiftly.

Still in beta, causing many changes in the framework and affects the development of the app.

Stable, all critical updates are implemented in a timely manner.

Generally stable, however support for some target platforms is still in alpha stage, which may affect the development of the app.

Cross-platform development challenges

Despite the attractiveness of cross-platform technologies, there are a number of questions and nuances that must be taken into account when planning development, timelines and budget.

Cross-platform software development cost

  • You can use Kotlin not only for the client app, but also for the server-side development.
  • You can implement shared logic below the UI layer.
  • Developers have unrestricted, direct access to both Android and iOS SDKs.
  • With Compose Multiplatform (additional technology from JetBrains), developers can reuse UI code across platforms. However, Compose Multiplatform is currently only stable for Android and desktop.
  • Beyond the virtual machine option (JVM), Kotlin Multiplatform allows compilation of native binaries using Kotlin/Native ensuring no loss in performance.
  • Officially supported platforms: Android, iOS (Alpha), MacOS, Linux, Windows, Web Wasm (Alpha).

Multiplatform app development risks

If you decide to dive into cross-platform development, it’s important to consider the following potential risks when planning the project:

  1. You may have to look for workarounds to access the hardware. Therefore, during the analysis and design phase, it is advisable to identify critical hardware requirements for your future product and decide on cross-platform technology. The same applies to target operating system functions (API calls).
  2. If your product needs to interact with third-party applications installed on the user’s device (for example, Google Maps), it’s crucial to ensure that the chosen framework supports such interactions.
  3. Since some cross-platform technologies use middleware (or bridges) in their architecture, you should keep an eye on the product’s performance.
  4. Cross-platform technology manufacturers typically lag behind updates to the target platform itself. Therefore, you need to ensure that the development framework considers crucial changes potentially affecting your product’s interactions with the target platform.
  5. In case of cross-platform mobile app development, you need to make sure that the approach you choose won’t drain the device’s battery or cause memory leaks, and will use the device’s storage sparingly.Additional attention is needed in case ofAndroid and iOS app development. In general, Google Play and the App Store have similar guidelines for reviewing apps.
    However, Apple has more stringent requirements for data backed up on the user’s device (point 2.23 of the iOS Data Storage Guidelines [10]
    ). Also according to requirement 4.2 (App Store Review Guidelines), ‘Your app should include features, content, and UI that elevate it beyond a repackaged website. If your app is not particularly useful, unique, or “app-like,” it doesn’t belong on the App Store’. This means that if you simply wrapped your website using cross-platform or hybrid technology and perhaps only added a login page, your app may be rejected by Apple.

Useful tips for cross-platform development

How can you minimize the costs of commissioning and further maintenance of software? Here are some tips that may be useful for cross-platform development, especially if you are working on a mobile app:

  1. Set up a continuous delivery process where each alteration in the source code will be checked for consistency and errors and automatically delivered to the required environment (test or production). For example, in the case of an iOS application, approved changes can be automatically compiled into a new build, verified using autotests and added to TestFlight ( for beta versions) or directly to the store. An experienced DevOps can handle this task.
  2. Plan time required to write unit and integration tests (so-called white box testing). Initially perceived as an extra expense, these automated tests run automatically during build phase, ensuringe development stability. The software developers themselves take charge of these tests.
  3. In addition to white box testing, you can add black box testing: automated tests written using specialized frameworks that simulate real human behavior. For example, toggling the location or Internet connection on the target device and check the app’s response. A proficient AQA specialist can develop such tests and thus reduce the time required for manual QA engineers to verify the acceptability of a new release.

Conclusion

We’ve only looked at the tip of the cross-platform development iceberg. There are several dozen cross-platform currently existing technologies, each of them with its own pros and cons.

How to choose the right technology then? The silver bullet for avoiding possible challenges with implementation of the required functionality or even the need to completely rewrite the software from scratch is hiring seasoned specialists. A system analyst and software architect can help you choose the appropriate technology stack, while a skilled project manager can cope with project timeline and development risks. Interested? Simply contact Timspark for a free quote.

Turn to Timspark for your cross-platform project

References

  1. Operating System Market Share Worldwide. StatCounter, 2024.
  2. What is .NET MAUI? Microsoft, 2023.
  3. 2023 Developer Survey. Stack Overflow, 2024.
  4. React Native. Meta Platforms, Inc, 2024.
  5. Out-of-Tree Platforms. Meta Platforms, Inc, 2024.
  6. Flutter Docs. Google, 2024.
  7. Get started with Kotlin Multiplatform. JetBrains, 2023.
  8. Why do teams adopt Kotlin? Google, 2024
  9. Stability of supported platforms. JetBrains, 2024.
  10. Optimizing Your App’s Data for iCloud Backup. Apple Inc., 2024.
  11. App Store Review Guidelines. Apple Inc., 2024.

KPIs for Remote Development Team: How to Measure Efficiency of Your Remote Engineers

KPIs for Remote Development Team: How to Measure Efficiency of Your Remote Engineers

“What gets measured gets managed.”

This quote is said to be from Peter Drucker, a leading management consultant from the 20th century. But the actual words go something like this: ‘What gets measured gets managed — even when it’s pointless to measure and manage it, and even if it harms the purpose of the organization to do so.’ And the credit goes to the journalist Simon Caulkin for coming up with those words.

Drucker, in turn, put it like this: ‘Moreover, because knowledge work cannot be measured the way manual work can, one cannot tell a knowledge worker in a few simple words whether they are doing the right job and how well they are doing it.’

We’re totally on board with Drucker here. People are more than just numbers, and there are various factors that can impact how effective software developers are. Plus, you can’t quantify passion, creativity, and commitment to company values with numbers.

Yet, when it comes to catching hiccups in a project, it’s crucial to use and scrutinize metrics and KPIs consistently. So, how do we do it in software development?

 

 

What is a KPI in the remote development team?

In software development, a key performance indicator, or KPI, is like a scoreboard for your team’s success. It’s a set of numbers and metrics that tell you how well your software project performs. Instead of guessing or hoping for the best, KPIs provide concrete data to show whether your team is meeting its goals.

For example, one KPI might track how quickly your team resolves issues or fix bugs. This helps you gauge the efficiency of your development process. Another KPI could measure user satisfaction, indicating whether people are happy with your software.

In a nutshell, KPIs are the numbers that keep your team on track and help you build high-class software.

 

 

Why are KPIs important in software development?

KPIs are crucial in software development, especially when working with remote teams or outsourcing projects. Here’s why KPIs are so important:

  • KPIs find and fix problems in making software, ensuring everything runs more smoothly and leading to better results.
  • KPIs are progress reports for software projects. They tell everyone how things are going, like a snapshot of the project. This helps manage the work better and plan for the future, so everyone knows what’s happening.
  • By keeping an eye on how things are going and making things better as you go along, you can avoid extra work and costs. It’s like fixing things before they become big problems, saving time and money.
  • KPIs also help make smart choices. Instead of guessing, use data to decide where to put our energy for the best results.

In essence, KPIs in software development represent a strategic roadmap. They navigate distributed agile teams through challenges and keep the work cost-effective, ending up in the delivery of high-quality software products.

 

 

When is it efficient to introduce KPIs to a remote software development team

Introducing KPIs will make sure you’re on the right track. But when is the best time to start using them? Use these three signs to decide:

  1. It’s not a quick project. If your project is a marathon, not a sprint, that’s the perfect time for KPIs. They work best when you have a bit of time to see progress and make improvements.

     

  2. You have clear milestones and deliverables. This way, you know where you’re going and can measure progress along the way.

     

  3. There’s at least a high-level project plan. Before you hit the road, it’s good to have a plan. Having at least a high-level project plan means you’re ready to start using KPIs to keep things on course.

So, if your project is more like a journey than a quick ride, with clear milestones and a roadmap in hand, that’s the efficient time to bring in KPIs and set up a smoother, more successful trip.

 

Types of KPIs for software developers team

Before we move to the custom software development KPIs, let’s take a short look at what matters for any project:

  • Schedule compliance: Keeps the development progress aligned with the planned schedule, highlighting reasons for deviations such as missing requirements or technical risks.
  • Accuracy estimate variance: Indicates how much the actual efforts deviate from the initial estimate, helping determine the remote development team’s velocity.
  • Budget variance: Tracks deviations from the planned budget, especially when involving unplanned expenses for specific tasks.

But just like with any project, details compose the whole picture. It is essential to break KPIs down to the level where production happens, finances flow, and customers use the software.

First, let’s take some time to explore the efficiency and workflow metrics and what decisions they help make on the way to successful delivery.

 

Productivity and workflow software development KPIs

KPI

How to measure

Example

Developer Productivity

Measure the output or work completed by a developer in a given timeframe.

Introducing a new task-tracking tool allowed developers to easily see their assignments, resulting in a 20% increase in tasks completed per week.

Velocity (Development, Sprint, or Team Throughput)

Calculate the amount of work completed in a specific time, often used in Agile methodologies.

Implementing agile methodologies led to a steady rise in sprint velocity, moving from completing 15 story points to consistently achieving 25 story points per sprint.

Progress and Performance Tracking Metrics

Monitor the progress of tasks and overall team performance against set goals.

Early identification of a critical bug allowed the team to address and fix it, preventing potential delays in the project timeline.

Sprint Burndown

Track the progress of a sprint in a Scrum framework by showing the amount of work remaining in the sprint.

The total work estimated at the sprint start is 100 story points. Day 1: 90 story points remaining. Day 2: 80 story points remaining. The ideal trend is a linear downward slope indicating steady progress.

Release Burndown

Track the progress of a release cycle in Agile development by showing the amount of work remaining until the release.

Plot the story points remaining. The chart will show a downward trend, ideally reaching zero by the end of the release cycle.

Cycle Time and Lead Time

Measure the time it takes to complete a task or deliver a product feature.

Streamlining development processes reduced cycle time from two weeks to one week per feature.

Wasted Effort Metric

Identify and quantify efforts that do not contribute to the project's progress.

Identifying and eliminating redundant tasks and unnecessary processes allowed the team to dedicate more time to essential project elements.

As you can see, we focus on executing tasks and regular monitoring. However, remember that the remote software development team’s motivation and comfort are always as important as their expertise and speed of accomplishing projects.

Software development performance and code quality KPIs

Checking how well the code performs and its quality is crucial. It helps start things like code reviews and testing on time. Plus, since distributed agile teams change, having good code becomes even more important. Gone are the days when developers wrote code just for themselves — now, it needs to be neat, accurate, and well-organized.

 

KPI

How to measure

Example

Code Quality Metrics

Evaluate the quality of code based on predefined criteria.

Improved code quality resulted in fewer post-release issues and increased customer satisfaction.

Code Coverage

Identify the share of code covered by automated tests.

High code coverage contributed to a robust and reliable software product.

Code Stability

Assess the stability and reliability of the codebase.

Ensuring code stability reduced the frequency of system crashes and errors.

Code Simplicity

Evaluate the simplicity and readability of the code.

Simplifying code improved maintainability and reduced the likelihood of introducing errors.

Code Churn

Measure the frequency of code changes, additions, or deletions.

High code churn prompted a review, leading to more stable and efficient code practices.

Customer satisfaction KPIs in software development projects

Keeping customers happy usually comes down to two things: how easy your software is to use and how well it solves problems. If any metrics show issues in these areas, the responsible remote development team gets a heads-up that improvements are needed.

KPI

How to measure

Example

Customer Satisfaction

Conduct surveys or gather feedback on user experience.

Achieving a 90% customer satisfaction rating.

User Adoption Rate

Monitor the rate at which users adopt new features.

80% of users adopt a new feature within two weeks.

Net Promoter Score (NPS)

Measure willingness of customers to recommend.

NPS of 8 or higher, indicating strong advocacy.

User Retention Rate

Track the percentage of users who continue to use.

95% retention rate over a six-month period.

Customer Support Response Time

Measure time taken to resolve customer queries.

Responding to 95% of customer inquiries within 24 hours.

Feature Usage Metrics

Monitor the usage of specific software features.

70% of users regularly utilize freemium features.

Conversion Rate

Track the percentage of trial users who become customers.

Achieving a conversion rate of 15% from trials.

Financial KPIs in software development projects

Finally, money matters, too. Software development isn’t just about pure coding; it includes steps like project discovery and business analysis. This means the whole project can bring in financial profit. That’s why we keep a close eye on financial metrics — to make sure the team did the job right and made the project a success.

KPI

How to measure

Example

Return on Investment (ROI)

Calculate the ratio of net gain to cost of investment.

Achieving an ROI of 20%, indicating a profitable project.

Cost per Feature

Evaluate the cost associated with developing each feature.

Keeping the average cost per feature below $1,000.

Revenue Growth Rate

Calculate the percentage increase in overall revenue.

Achieving a revenue growth rate of 15% per quarter.

Development Cost Ratio

Compare development costs to overall project budget.

Keeping development costs below 30% of the total budget.

Customer Acquisition Cost (CAC)

Calculate the cost to acquire a new customer.

Maintaining a CAC below $50 per new customer.

Profit Margin

Determine the percentage of profit relative to revenue.

Maintaining a profit margin of 25% or higher.

Time to Payback

Measure the time it takes for a project to generate profit.

Achieving payback within 12 months of launch.

These financial indicators tell us how the project is doing now and how it could make more profit in the future. Again, any differences can be specific to each case, showing problems in different parts of the project.

 

 

When KPIs might not be useful

KPIs are powerful, but they shouldn’t stifle creativity and innovation. Use them as guiding principles, not rigid constraints. Allow flexibility within the development process, balancing the pursuit of KPI targets with the need for exploration and creativity.

We recommend seeing KPIs as tools that inform decision-making rather than strict rules. This approach ensures that development teams can adapt, experiment, and foster a culture of continuous improvement.

 

How to avoid micromanagement when placing KPIs


Implementing KPIs is like steering a ship — you want to set the course without becoming too controlling. So, we offer ten steps to make sure you empower employees with this tool rather than constrain them:

  1. Lay out why KPIs matter and how they tie into the bigger picture. When the remote development team understands the ‘why,’ they’re more likely to sail in the right direction independently. 
  2. Get your team’s input on setting targets. When they have a say in the destination, they’re more invested in the journey. 
  3. Keep the focus on what needs to be achieved, not how to get there. This allows your team to chart their own course and find creative solutions. 
  4. Drop anchor regularly with team check-ins. Open communication minimizes the need for constant oversight and keeps everyone on course. 
  5. Harness the power of trust. When your remote development team feels trusted, they navigate their responsibilities with confidence and skill. 
  6. Arm your crew with the tools and training they need. This empowers them to navigate challenges without waiting for your command. 
  7. Hoist the flag for every achievement. Celebrating successes builds morale and motivation without having to keep an eagle eye on every move. 
  8. Be ready to adjust the sails with changing winds. Flexibility in adapting KPIs ensures that your journey stays on course, even through unexpected waves. 
  9. Lead from the helm, striking the right balance between guidance and letting your crew steer. The way you lead sets the tone for the entire project. 
  10. Instead of handing out maps for every challenge, encourage your crew to plot their own course. Fostering a culture of self-sufficiency turns your team into seasoned navigators.

These ten steps will help you chart a course with KPIs, making your remote development team sail toward success without feeling like they’re under a watchful eye at every turn.

 

Manage the measurable, nourish the immeasurable

 

In the world of software development, success isn’t just about hitting numbers; it’s about the passion, creativity, and commitment that drive projects forward. While these aspects might not fit neatly into spreadsheets, they are the heartbeat of any successful endeavor. However, the strategic use of KPIs is essential to keep projects on track and tackle challenges effectively. KPIs act like a roadmap, helping distributed teams in agile navigate complexities without losing the human touch.

If you’re looking to ace the KPI realm, especially in the remote work setup, consider teaming up with Timspark, the experts in optimizing KPIs for remote engineers. Let’s collaborate and turn your software development journey into a data-driven success story. Ready when you are!

Top 7 Unrealistic Expectations at the Project Discovery Phase and How to Resolve Them

Top 7 Unrealistic Expectations at the Project Discovery Phase and How to Resolve Them

10 min read


The discovery phase is a vital time when clients and development teams come together to share their dreams and expectations
for a successful project. It’s all about teamwork and understanding each other’s vision to create something truly amazing. Of course, sometimes this phase comes with its own set of challenges, like tackling those tricky, seemingly impossible requirements.

No worries, though, we’re here to guide you through the heart of the discovery phase, highlighting its significance and offering strategies to handle and adjust any unrealistic expectations smoothly. 

Read on to learn how to make your project a shining success from the start.

 

What is the project discovery phase?

The discovery phase is the first step in the project life cycle.

It’s a time for you and the development team to understand and write down what the project needs, aims to achieve, and what limits there might be.

You’ll have deep conversations to make sure everyone agrees on the plan before any real building starts. It helps everyone have the right expectations, look at different options, and create a practical plan for your project.

 

Project discovery phase

During the project discovery stage, you’ll gather all the important market and user research data you need to make good choices. You’ll decide on things like:

  • Design style
  • Features for the first version of the product
  • Best technology to use for the product

In the end, you’ll usually have such discovery phase deliverables as a UI prototype, some documents, like a project roadmap, and a clear vision of what success looks like for your product.

 

Why have a project discovery phase?

Project discovery is really important for a few key reasons. First, it helps figure out exactly what the project is about and what limits it might have, stopping any unexpected changes and keeping things on the right path.

Second, it ensures everyone understands what you need and want, which matters a lot for making a product that fits those needs.

Third, it’s a chance for the development team to tell you about what can and can’t be done technically, helping make a feasible plan.

In short, the discovery stage is when your knowledge and the tech team’s knowledge come together. You both have important things to share and decide on before putting time and money into the project.

Although every project is unique, we’ve compiled a list of the most common unrealistic expectations that can slow things down. Check out this list to stay ahead from the start and keep your project on the path to success.

 

7 common unrealistic expectations to tackle at the project discovery phase

It’s not unexpected that the most common unrealistic expectations are about the project’s roadmap, mismatched visions, and communication issues. As you review them, you’ll see why it’s best to address each issue right from the start of the project.

Expectations at project discovery phase

Unrealistic deadlines

We often see impossible timelines. They come from not understanding the complexity behind the tasks and believing that adding more people can shorten the development time. However, some processes just can’t be expedited with 300 developers and need more realistic timelines. 

We’ve witnessed people misleadingly believe that a complex system can be delivered in two months with just more people. Unfortunately, it’s not how things work.

24/7 availability of developers

Some clients might think developers should be available all the time. This isn’t effective most of the time and can cause burnout. It’s important to be clear about when developers can work and contribute. If you believe you need support all the time, you should be ready to allocate more budget for that or look for a team that works in different time zones to cover the whole day.

Mismatched technology visions

You might have some popular technologies in mind that you want to use, and that’s great. But it’s important to figure out if the tech stack you mean even fits your product idea. Often, clients prefer to contact consulting agencies first to find out what kind of stack they need. However, with no hands-on experience, agencies tend to refer to the most widespread technologies, too.

Overambitious requests

Requests for advanced technology like AI without a clear understanding or provision of necessary algorithms are common, too. Again, the vendor team is the one to closely communicate this issue with you and define realistic technologies to serve your users.

One day, we discussed a medical AI-based system that would independently match patients with the recommended treatment. However, the client lacked a vision of the concrete algorithm to complete the task. What we’re trying to say is that when we have such a big gap in business logic, the discovery phase is the right time to close it together.

Incompatible requirements

You may want everything under the sun — high-quality video recognition, unlimited storage, and instant access worldwide on a limited budget. It’s important to navigate these requests carefully, prioritizing and finding workable solutions.

A good example is when you work with multimedia, such as video content. You may want to store your content forever and have real-time access because it seems valuable. It’s obviously a costly thing to do. Here, it’s better to know exactly how often you need to refer to this or that content and make the right storage and access decisions, especially if you are tight on budget.

Design on a dime

Sometimes, people from different fields might not realize how fundamental the design phase of a project is and think programmers can just take care of it. But the user interface is the first thing users see, and developers may just lack this visual taste you may want to communicate to your end-users. Skimping on design could make it hard to attract users and sell your product.

Integration with numerous devices

Clients might ask for their product to work with lots of different devices, but this can make things much more complicated and expensive. A smarter way is to figure out which devices are primary for your users and focus on those first.

One of the client requirements we can recollect is the need to integrate with all types of smartwatches and bracelets to track sleep quality and movement data. As a result of a thorough discovery, we decided to go for some Samsung and Apple models only because they were more common choices by the target audience.

You’ll see that the entire discovery phase is about making the best use of your budget and time and improving the product instead of just pushing what one side wants. Through open and clear communication, you can find common ground that meets all your needs and sets the stage for a successful project.

How much does it take to make project discovery?

The cost of the project discovery phase can vary significantly depending on the project’s complexity, your needs, and the team’s expertise. However, adopting a shift-left approach, where discovery is seen as an investment rather than a cost, can save time and money in the long run.

By identifying and addressing potential issues early, you reduce the likelihood of costly mid-project changes and ensure a smoother development process.

Set the stage for a realistic project delivery

As we’ve journeyed through the twists and turns of the discovery phase of a software project, it’s clear that understanding and managing expectations is the key to a smooth, successful delivery. Remember, every hurdle you clear and every detail you nail down now is a step closer to bringing your vision to life. 

So, if you’re feeling overwhelmed by the challenges or just need a guiding hand to help navigate these crucial early stages, Timspark is here for you. Our team is dedicated to turning your ideas into reality, and we’re just a message away.

Let's discuss your project!

Timspark’s 2023: Reflecting on a Year of Progress and Looking Forward to a Bright Future

Timspark’s 2023: Reflecting on a Year of Progress and Looking Forward to a Bright Future

Dear Colleagues, Partners, and Readers,

The end of December is the perfect time to reflect on why 2023 is so special to us. Timspark is celebrating its first anniversary, and what a remarkable year it has been!

The primary highlight is the portfolio of outstanding solutions we’ve developed together. We’re truly amazed by the innovativeness of our customers and strive to grow even more to keep up. Just look at how we:

These are just a sneak peek into the vivid and versatile portfolio that we’ve gathered over this year of productive collaborations.

Even more, in 2023, we unite exceptional talent from diverse backgrounds:

  • 36 beautiful, ambitious, expert people
  • over 30 core and augmented teams
  • 1000+ vetted engineers

Finally, this past year has been so memorable for our participation in various IT events. We’ve had the privilege of attending the EMO Hannover, Gitex Global, Medica Health IT Forum, and other notable events. There, we’ve learned from industry experts and connected with fellow technology enthusiasts. These experiences have deepened our knowledge and perspective, and we can’t wait to share what we’ve learned with you in the coming year.

As we look ahead, we have some exciting projects in the pipeline, including more sophisticated DevOps implementations, powering industries with advanced data management and AI, mobile transformations, and others. Stay tuned for what’s to come!

As we celebrate the holidays and approach the new year, we wish you and your loved ones a joyful, peaceful, and prosperous holiday season. May your days be filled with warmth, laughter, and the company of those who matter most.

Thank you for being a part of our first-year celebration, and here’s to a bright and promising future together. Happy holidays and a happy new year from all of us at Timspark!

A Comprehensive Guide to Software Development in Healthcare

A Comprehensive Guide to Software Development in Healthcare

The union of IT and healthcare has brought medicine to a new qualitative level.

Medical services have become more accessible: you no longer need a face-to-face appointment with a doctor; instead, you can use telemedicine software and get the necessary advice online. With diagnostic tools from the Internet of Medical Things  (IoMT) subset, you can perform remote monitoring of your health. The past pandemic has highlighted the significance of prioritizing one’s well-being. The Zoomer generation as a whole advocates a health-conscious and eco-friendly lifestyle. All these factors point to one conclusion: healthcare software development is more relevant than ever.

According to Precedence Research, the global medical software development market size is valued at $28.66 billion in 2022 and is expected to reach approximately $77.43 billion by 2032. [1]

Now, what do you need to start your own software development in healthcare?

Challenges of software development in the healthcare industry

Before you start developing a healthcare application, it’s crucial to understand all the nuances involved. Healthcare software development often requires mandatory certification that evaluates the software safety of the end users. Skipping important steps when creating such a product may, at best, lead to its reclassification as a Wellness application. At worst, it might lead to looking for new investments to fix the issues and once again pursue obtaining the coveted CE mark. In addition to direct cash investment, time to market is an essential factor to consider.

According to publicly available data, between 75% and 98% of healthcare startups fail. Reasons vary, but certification issues stand out as a primary concern, which, in turn, slows down the delivery of software to end users.

The gold standard for healthcare software development

Does any medical software require certification from a notified body? Some healthcare applications can undergo self-certification, while others do not need to be certified at all.

For example, an electronic health record (EHR) system exclusively used for retrieving, storing, or archiving medical data does not require certification. However, if the software is used for personal diagnosis and/or prescribing a personalized treatment plan, it is already classified as a medical device and, therefore, must comply with IEC 62304. IEC 62304 is a gold medical software development standard adopted in the European Union and the United States.

Healthcare software development in accordance with IEC 62304 ensures that it is created within a defined and controlled environment. Such a development process should align with requirements aligned with the software safety class.

Safety classification in healthcare software development

To determine the need for certification, the software developer must specify a safety class (A, B, or C) for their healthcare application. The safety class is based on the risk of harm the software may cause to the end user. According to IEC 62304 the following classification is used:

  • Class A: The software cannot cause any damage or injury;
  • Class B: Software may cause minor injury;
  • Class C: Software can cause serious injury or even death.
Does medical software require certification?

Class A software can be self-certified. To obtain the CE mark, it is enough to declare adherence to the IEC 62304 standard and publish a control document that lists the main points of compliance with the requirements.

Class B software requires the participation of a notified body to confirm that the software development process complies with the requirements of IEC 62304.

In the case of class C, the notified body will thoroughly analyze the development process and design documentation and check the software itself.

When a software product bears the CE mark, it indicates that it has passed the necessary assessments and is safe for use.

Essential documentation for developing medical software

The IEC 62304 standard governs the healthcare software development process. Specific project documentation confirms that all necessary steps have been completed. Depending on the assigned safety class, the following set of documents is required:

Document

Class A

Class B

Class C

Software development planning

yes

yes

yes

Software requirements analysis

yes

yes

yes

Software architectural design

yes

yes

Software detailed design

yes

Software unit implementation

yes

yes

yes

Software unit verification

yes

yes

Software integration and integration testing

yes

yes

Software system testing

yes

yes

yes

Software release

yes

yes

yes

Each document should have a clear structure and be created as the project progresses, as recommended by IEC 62304. For example, before you start medical software development, you should have a software development plan. Before formulating the project’s scope, you should define the software requirements. Of course, these documents will not be set in stone; they might be updated according to changing project requirements. However, having them in place makes healthcare software development more manageable.

As a last resort, documentation may be recreated before certification to showcase that the overall development is aligned with the guidelines.

Local regulations on software development for healthcare

The IEC 62304 standard governs the medical software development process. Additionally, it is crucial to consider standards such as:

  • IEC 60601-1 specifies network, software interfaces, and hardware requirements;
  • IEC 62366 specifies usability requirements for the development of medical devices.

However, beyond the development process, you must also remember that the final product must comply with local legislation. If you produce software for EU residents, it must comply with the GDPR. When using healthcare software in the US, it must be HIPAA compliant, and if the application processes children’s data, checking for CAPTA compliance is advisable. In the US, there are variations in the requirements for medical software, even at the state level. Therefore, when starting healthcare software development, it is better to rely on professionals familiar with the nuances of implementing such products for a specific region.

SOUP and OTS components used in healthcare software development

Today, development cannot be done without integration with third-party software. However, it is not always known whether the integrated component meets the required standards.

For healthcare software development, third-party components fall into certain categories:

  • Off-The-Shelf Software (OTS Software): A publicly available software component used by a medical device manufacturer, where the manufacturer cannot claim complete control over the software life cycle;
  • Commercial off-the-shelf software (COTS software): OTS software supplied by a commercial vendor;
  • Software of Unknown Provenance (SOUP Software): A widely available software component not explicitly designed for integration into a medical device or previously developed software lacking corresponding development records.

Certain components can be both SOUP and OTS. To integrate such third-party software, the developer must assess the risks and the overall software safety class. All such integrations should be reflected in the software architectural design, along with a rationale for choosing particular components.

Testing specifics in healthcare software solutions development

Although the IEC 62304 standard provides a clearly defined procedure for testing medical software, it is worth touching on a few more points, that may not be immediately obvious:

  • For a successful release, you will need several sets of data for testing:
      • Stub data that contains no sensitive patient data or other confidential information and can be accessed by any team member. It must be prepared before development starts;
      • Real test data may already contain sensitive information, meaning that access rights must be defined for it. Software developers and QA engineers may use stubs (test data) if they lack access to real data. However, team members, including the business analyst, solution architect, project manager, and possibly the QA lead, must be able to analyze real data in advance to design the proper data model and conduct final testing. The absence of real data at the development stage is fraught with failure when testing the product with real users. These can range from trivial user interface errors (like poorly formatted text or not fitting into a label or is and therefore unreadable) to more critical errors when saving data to the database;

 

  • The project roadmap should include alpha and beta testing with real users. No matter how professional the contractor is, user acceptance testing should involve the target audience. Since what is convenient for technical specialists may be completely unobvious and inconvenient for real users;
  • While not explicitly required when developing medical software, test cases are highly recommended to create and maintain. Depending on the safety class, the cost of an error in medical software may be too high, causing harm to human health and life. This means the development team must consider all possible negative scenarios and ensure that the software handles unusual situations correctly. The same goes for cybersecurity testing — healthcare systems must be as secure as possible from hacking. A backdoor can give attackers control of the application and pose a risk to the patient’s health.

Hosting for medical software development

The correct choice of hosting provider also affects the success of software development in the medical field. While a small mobile application without a server part may not cause hosting concerns — simply uploading it to Google Play or the App Store suffices — once your software has a server side, several crucial factors come into play:

  • Hosting availability (or total uptime) to ensure access to healthcare services; this factor might be quite important for hospital management software;
  • Existing services (e.g., Kubernetes) for system self-recovery;
  • Availability of hacking protection to guarantee data security;
  • Hosting compliance with required standards (for example, GDPR or HIPAA).

Maintaining a balance between the above requirements and the associated hosting costs is equally important.

Winning 12-step strategy for healthcare software development

To successfully launch a healthcare startup and stay on budget, the following action plan should be implemented:

1. First, define the core concept of the software being developed, emphasizing the killer feature that sets it apart from the competitors. Integrations with third-party components can replace everything else at the initial stage. At the same time, it is essential to consider the specifics of using SOAP and OTS.

2. Next, determine the target audience. In software development in healthcare, the age of the end users should be considered very carefully, especially when adhering to legal restrictions for minors. A parent mode is essential if the final product is intended for children. Otherwise, we will have to exclude kids at the registration step.

3. To validate the software idea for potential investment and present it to stakeholders, create a clickable UI prototype in Figma or InvisionApp. By visualizing the requirements, you can validate the idea itself.

4. Work on the software requirements analysis (according to IEC 62304) along with the clickable prototype. Since most current software development is based on Agile methodology, the requirements specification will be updated as the project progresses. However, for a stable release, it is crucial to freeze requirements changes at least a month before user acceptance testing.

5. Once the specification and user interface design are approved, start working on the architectural design required for the Class B and Class C software. This step enables stakeholders to calculate the total cost of ownership.

6. Meanwhile, the project manager is supposed to plan the project milestones and deliverables and approve the final roadmap with the customer.

7. It is recommended to start healthcare software development with the riskiest features to verify the key business idea of the project and ensure smooth integration with third-party components. This means common features such as registration and login can be postponed for later.

8. Prepare a limited group of real users for user acceptance testing in advance. This is especially true for testing the alpha version since it may still contain bugs. The beta version may be available to a broader group of real, sometimes even casual, users. During alpha and beta testing, the crucial goal is to collect user feedback and fix the most critical issues.

9. Conduct security and load testing to ensure the software’s reliability and fault tolerance.

10. Establish isolated environments to conduct different types of testing and carefully plan the expenses to support them at the architectural design step. The TEST environment will only be available to the development team to test the implemented changes iteratively. The STAGE environment should only be used for user acceptance testing. The PROD environment is intended for final releases. All these environments require isolated hosting, i.e., they use separate resources (such as memory, file storage, and database).

11. Finalize the necessary documentation and undergo certification for software with safety classes B or C.

12. Maintain a support team from the very launch of the product to handle user feedback promptly.

Steps 3-5 look aligned with the Waterfall methodology but are crucial for smooth healthcare software development and effective management of the project budget.

Bonus: Ideas for startups in healthcare

Despite the ongoing evolution of healthcare software solutions development over decades, the space for startups in this field remains open. Moreover, the introduction of AI has impeded advancements in health software development. Here are some thoughts from Timspark on what kind of software can be designed for healthcare:

B2C healthcare solutions

Thanks to the widespread adoption of smartphones and other wearable devices, people can use apps to track their health; for example, mobile phone sensors can be used for posturography. Meanwhile, artificial intelligence solutions assist doctors in creating personalized treatment plans. A tireless AI-powered personal assistant can support seniors 24?7. Digital front door in healthcare can help patients receive better services promptly.

B2B healthcare solutions

Clinics and labs have diverse software needs, ranging from applications that track the movement of rare equipment around a clinic to computer vision that monitors seriously ill patients and recognizes their emotions 24/7. Particular attention is paid to clinical software development, aiding doctors in identifying dangerous deviations in patients’ health. Many of those healthcare solutions lie in the field of AI technologies.

Launching a project in healthcare software development?

Would you like to dive into hospital software development, or are you wondering how to build a healthcare technology platform? We would be happy if our article became your guide to launching your first startup. However, due to the text’s brevity, we couldn’t address all the intricacies of healthcare software design. Therefore, we’re eager to assist you in your ventures by staffing your team with the necessary software developers or completely taking over the implementation of the project. Our leading experts will help you optimize costs and guide you through the entire software development lifecycle.

Looking for a healthcare software development company?

References

  1. Healthcare Software As A Service Market. Precedence Research, 2022.
  2. What Leads to Company Underperformance & Failure?  TTi Health Research & Economics, 2021.
  3. Startup Failure and Success Rates: 2023 Research.  StartupTalky, 2023.
  4. IEC 62304:2006. Medical device software. ISO, 2021.

Let’s build something great together

    Let’s build something great together

      Let’s build something great together

        Let’s build something great together

          Let’s build something great together

            Let’s build something great together

              Let’s build something great together

                Let’s build something great together

                  Let’s build something great together