How We Helped Lumenis Transform Their Digital Ecosystem and Enter the Chinese Market

Lumenis is a global company that produces medical devices used in aesthetics, ophthalmology, and surgery. They operate in many countries and serve both clinics and hospitals. In 2023, Lumenis started a digital transformation. They wanted to replace an old internal system with a modern, cloud-based solution, and they chose Valletta Software as a technology partner.

At first, we joined the project just to review the code. But step by step, our role grew. We helped fix serious technical issues, rebuilt the backend from scratch, and delivered key releases on time. Later, we worked on expanding the system for new use cases, including an urgent adaptation for the Chinese market.

From Code Review to Full Control

Our journey with Lumenis began quietly, just a standard code audit. But what we found behind the scenes told a different story.

The system had been in development for years, but things weren’t going well. The app was built only for mobile devices, even when used on desktops, causing serious UI and layout issues. The codebase was tangled and buggy. Timelines kept slipping. The internal team was overloaded and reluctant to let outsiders step in.

At that point, Valletta Software’s role looked like this:

• No access to the main code repository
• Bug fixes delivered as ZIP files
• Long instructions explaining how to merge our changes manually
• No clear ownership or ability to move quickly

Despite all that, we didn’t walk away. We kept shipping fixes, suggesting improvements, and staying consistent. Slowly, our technical input started making a difference: stability improved, deadlines stopped moving, and the client began to see us not as outsiders, but as problem-solvers.

Then things changed.

We were granted full access to the codebase. This allowed us to:

• Work directly with the main branch
• Clean up technical debt
• Optimize performance
• Deliver updates without delay

By late October 2023, Lumenis asked us to finalize the system for production use. The architecture still had weak points, and performance needed serious tuning, but we got it done. The system went live, stable, working, and ready to serve real users. What started as a side role turned into full ownership.

Taking Ownership: From Maintenance to Real Impact

Once we had full control over the codebase, our team at Valletta Software could finally work the way we were used to: cleanly, directly, and fast. And it was just in time. The system had to be stabilized, bugs closed, and performance brought up to a level acceptable for real-world use.

The client had made a clear decision: stop working with the original vendor and hand over the product to us. This was a sign of trust, but also a responsibility. The system wasn’t small. It had grown over 15 years, passed through several teams, and supported multiple product lines. In short: it was large, slow, and expensive to maintain.

Together with Lumenis, we made the call: it was time for a full rebuild. We kept the customer-facing app (for now), but everything else (backend and admin panel) would be re-engineered from scratch. That meant:

• A brand-new API designed for scalability
• A backend built using AWS Lambda and serverless architecture
• An admin interface built with modern React
• CI/CD pipelines and infrastructure designed and managed by us

We didn’t just maintain the system. We transformed it, using our experience to turn a heavy legacy product into a fast, cloud-native platform that would support Lumenis’ next stage of growth.

Rebuilding the System from the Ground Up

Once the legacy platform was stabilized, we came to the conclusion that continuing to support it made little sense. The backend was too large, outdated, and slow to respond to the needs of modern users. So we partnered with Lumenis to rebuild the system from scratch, keeping only the customer-facing app and replacing everything else.

To keep the project realistic, Lumenis split development into three clearly defined phases, each with internal releases and feedback loops. Meanwhile, business analysis continued in parallel, which meant we had to adapt quickly and often revise our estimations.

At the same time, Lumenis was shifting its infrastructure to AWS cloud services. To meet performance and scalability goals, we proposed a fully serverless architecture, built around:

• AWS Lambda for executing backend logic
• API Gateway for managing requests
• DynamoDB and S3 for storage
• CloudFormation and Terraform for provisioning
• GitHub Actions for CI/CD pipelines

This introduced new challenges:

• Many standard backend frameworks didn’t work well in serverless environments
• We had to build our own lightweight internal framework for routing, validation, and error handling
• Cold start times and deployment flows required specific tuning and testing

To meet the demands of this new architecture, we expanded the team:

This technical leadership played a key role in shaping the project. It allowed us to define consistent development standards and workflows, maintain high code quality through regular reviews and shared conventions, and make fast, informed architectural decisions even when the business requirements were still in flux.

Despite the complexity, each phase was delivered on time. The result was a fast, modular, cloud-native backend platform, with an admin interface that could support daily operations and future business features.

Key Challenges and How We Solved Them

Rebuilding a large system is never simple, especially when requirements are incomplete, deadlines are tight, and new technologies are being introduced mid-flight. The Lumenis project presented a number of serious challenges, both technical and organizational. Here’s how we approached them.

1. No documentation, unclear scope

The original system had evolved over many years with minimal written documentation. Our job was to reproduce its core functionality in a new architecture, without a clear feature list or business logic description.

To solve this, we worked closely with the client’s project manager, who acted as the domain expert and proxy analyst. Our team actively joined calls, asked clarifying questions, and validated assumptions. Instead of formal specifications, we relied on communication and live testing to define behavior. This required initiative, flexibility, and constant alignment.

2. Parallel analysis and development

The business logic was often still under discussion while we were already building it. Traditional estimation wasn’t possible, since the scope was shifting. To manage the risk, the client split the work into three delivery phases, each with specific functional goals. This gave us clarity in short-term goals and allowed the client to adapt plans between phases based on real progress.

3. Performance issues in the frontend

One of the key goals of the rebuild was better performance. However, during internal testing, we saw that the new client application wasn’t performing any better than the old one.

We paused and prepared a performance improvement plan, supported by real measurements. To make sure the plan was solid, we brought in external experts for review. The final strategy was agreed with the client and implemented quickly. As a result, we achieved a measurable improvement in frontend responsiveness and overall speed.

4. Security and compliance

The platform stores personal health data and had to meet strict security requirements. Lumenis ran both manual and automated penetration testing using external tools. Our DevOps engineers were responsible for resolving all identified issues, often under time pressure.

Security tasks were prioritized alongside features, and progress was tracked daily by the project manager. Thanks to close coordination and extra effort from the team, we passed the compliance checks without blocking the production launch.

Expanding the Platform: A New App for Clinic Networks

While work on the main system continued, Lumenis identified a new business need – to develop a separate application for managing clinic networks. Unlike the existing customer app, which was used by individual clinic staff, this new tool was designed for regional and national managers who needed visibility across multiple locations.

The idea was ambitious and came with a high volume of new work that wasn’t part of the original roadmap. To meet the demand, Valletta Software expanded the team:

The development started without finalized requirements. Many key questions were still open, and the delivery deadline had already been set. While the date shifted a few times due to external factors, the pressure on our side remained high. We had to move forward with limited information and iterate quickly.

The core functionality of the new application focused on:

• Aggregating telemetry data from medical devices used during procedures
• Calculating key performance metrics across clinics
• Displaying the results using customizable dashboards and diagrams

This was fundamentally new functionality; the old system had nothing similar. Our team had to design the data architecture, processing logic, and visualization pipeline from scratch.

We evaluated two implementation options:

1. Use AWS services like QuickSight and Athena. This approach was proposed by the client. It offered the promise of flexibility and the ability to add new reports without much involvement from the development team. However, our team had no previous experience with these particular AWS services, which introduced uncertainty in terms of delivery time and support.
2. Build a custom solution using a charting library integrated into the frontend. This was our suggestion. It required more effort upfront on both the backend and UI sides, but offered noticeably better performance in the browser. It also gave us full control over how the charts looked and behaved, making it easier to follow the design specifications provided by the client’s UX team.

The client leaned toward the second option, though no final decision was made, because in February 2024, the project was frozen due to a shift in business priorities. Still, much of the architectural groundwork was complete, including a working method for turning telemetry into meaningful metrics and visualizing them inside a web interface. These results may be reused in the future.

Entering the Chinese Market

Toward the end of 2024, Lumenis launched a high-priority initiative to expand into the Chinese market. China is their second-largest region in terms of potential sales, but results had been underwhelming. The company decided to boost engagement by adapting the existing customer-facing app for Chinese clinics and patients.

From the start, the timeline was aggressive. The project was directly overseen by Lumenis’ VP in China, and the initial release was expected before the New Year (an almost impossible deadline). One option discussed was releasing a version with only “coming soon” banners, but the final goal remained a working application, tailored to local needs.

Key goals of the China release included:

• Translating the customer app into Chinese
• Adjusting several UI elements for regional specifics
• Adding the ability to manage China-specific content (e.g., media and product catalogs) in the back office
• Importing real user and device data from Chinese clinics

In terms of infrastructure, there was no separate deployment for China. All new features had to be delivered within the same environment that served U.S. users, without disrupting ongoing operations. That required careful coordination across testing, deployment, and feature flag management.

Given the urgency, Valletta Software rapidly reallocated resources. In December 2024, we brought in an extra frontend developer and increased the hours of our part-time DevOps engineer. All other team members were instructed to prioritize China-related tasks exclusively, unless no such tasks were available.

The biggest technical dependency was the WIZ analytics module. It relied on telemetry data from a new generation of devices that had not yet entered the Chinese market. While 15 of these machines were already ordered, the analytics feature couldn’t be included in the first release as the full data pipeline was not yet operational.

Despite the challenges, we delivered in two stages:

To stay on track, our developers also participated in manual testing (something they don’t usually do). The project was treated as an all-hands-on-deck priority, with the team fully focused and daily progress tracked in close coordination with the client.

Although the system is not yet live for Chinese users due to data quality issues on the client’s side, the software itself is ready and production-tested. From our side, all deliverables were completed on time, and the client was satisfied with the result.

Results and What’s Next

By the end of 2024, the new system we built for Lumenis was fully deployed and running in production. All three development phases had been completed, the legacy system was phased out, and the new backend and admin panel were now the operational core of the business. The transition was smooth, and every key milestone was delivered on schedule, despite all the moving parts, scope changes, and parallel streams of work.

Since launch, Valletta Software has remained the technical partner responsible for system maintenance and ongoing development. We’re currently supporting the platform in several directions:

• Fixing bugs and handling technical issues reported by users
• Implementing new features requested by the business team
• Gradually rewriting the customer-facing app in React, with added support for tablets and desktop screens
• Planning and designing a system monitoring setup using Site24x7

The monitoring initiative came from the DevOps team after they attended a client-organized training session. They proposed Site24x7 as a good fit for the platform, and the idea was well received. At the moment, we’re working on a step-by-step rollout plan.

In parallel, the architecture for processing telemetry data (developed as part of the clinic network app) remains available for reuse. Even though that particular application was paused, the logic for calculating and visualizing medical performance indicators is still valuable. The client is considering ways to apply it in other contexts.

Overall, the collaboration with Lumenis has grown far beyond its original scope. From a small audit to full system ownership and strategic product launches, we’ve supported their digital shift at every stage. The systems we’ve built are now at the heart of daily operations, and we continue to evolve them together.

Conclusion

What began as a limited engagement quickly turned into a deep, long-term partnership. Working with Lumenis, we faced outdated systems, shifting requirements, tight deadlines, and unfamiliar technologies. But through close collaboration, technical leadership, and a practical approach, we delivered working software on time and at scale.

At Valletta Software, we don’t just write code. We help our clients rethink how their systems work, adapt to new business goals, and respond to market demands, whether it’s a full system rebuild, cloud migration, or urgent expansion into a new region.

The Lumenis project is a great example of what happens when trust, ownership, and expertise come together. And we’re proud to keep building on that foundation.