Successfully managed conflicts and ensured customer satisfaction within timelines and budgets despite changes in project schedules and priorities (ALM, Clear Case, Clear Quest, UCM).

Applied the OOAD methodology to the development of the embedded core software for the BIONIC elevator system.

• Oversaw software architecture design, ensuring adherence to SOLID principles and promoting the use of appropriate design patterns to enhance maintainability, scalability, and testability.
• Utilized UML modeling to document and communicate system structure and behavior.

Key design patterns implemented:

• Singleton – Ensures a class has a single instance and provides a global point of access.
• Abstract Factory – Defines an interface for creating families of related or dependent objects without specifying their concrete classes.
• Facade – Simplifies access to complex subsystems by providing a unified interface.
• Observer – Establishes a one-to-many relationship so that changes in one object automatically notify and update dependent objects.
• State – Allows objects to change behavior based on their internal state, effectively changing their class at runtime.

Defined classes, methods, and relationships directly within the UML model using tools such as Rational Rose and IBM Rhapsody, enabling the automatic generation of C++ source code.

By leveraging model-driven development, we ensured that the UML diagrams remained synchronized with the codebase, maintaining consistency between design and implementation and guaranteeing up-to-date documentation throughout the software lifecycle.

Created comprehensive Software Requirement Specifications (SRS) for complex real-time multitasking systems, defining system behavior in a structured and deterministic manner.

Each SRS document included:

• Initial Condition
• Trigger Event
• Expected Behavior
• Final Condition
• Alternative Flows for handling exceptions and unexpected inputs.

Example – Elevator System

• Initial Condition: Door is open
• Trigger: Door open timer expires
• Expected Behavior:
  • Door starts closing
  • Door reaches fully closed position
• Final Condition: Door is closed
• Alternative:
  • Event: Photocell activated during door closing
  • Behavior:
    • Door reopens
    • Door is open
    • Door open timer is restarted

This approach ensured clarity for developers and testers, reducing ambiguity and enhancing reliability for safety-critical systems.

Ensured the development of robust, maintainable, and scalable software by consistently applying the SOLID principles and leveraging proven design patterns.

SOLID principles followed:

• Single Responsibility Principle (SRP): A class should have only one reason to change.
• Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification.
• Liskov Substitution Principle (LSP): Objects of a superclass should be replaceable with objects of its subclasses.
• Interface Segregation Principle (ISP): No client should be forced to depend on methods it does not use.
• Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions.

Implemented a single software solution capable of supporting both new elevator installations and modernization projects, despite variations in hardware and peripherals.

New installations use a standardized setup: a predefined drive system, door type, Car Operating Panel (COP), and Landing Operating Panel (LOP). Modernizations, on the other hand, involve a mix of legacy and new components—various types of drives, doors, COPs, and LOPs. Additionally, the main control boards differ in terms of CPU, I/O capabilities, and memory size.

To handle this diversity, the software performs hardware detection at startup and initiates a learning trip to collect all necessary configuration data to operate correctly.

Thanks to the abstraction layers implemented, we were also able to develop a Windows-based simulator for PC, enabling effective testing and validation of the system in a simulated environment.

Introduced and led a structured Agile approach based on one-month sprint cycles, ensuring continuous alignment with customer needs and feedback.

I was responsible for the end-to-end planning and coordination of each sprint. This included gathering new requirements, defining implementation strategies, assigning tasks to developers, managing and prioritizing the backlog, setting clear testing objectives, and addressing bugs based on their severity and impact.

This methodology enabled a more transparent and responsive development process, with consistent delivery of value and improved collaboration across the team.

Promoted continuous improvement through effective backlog management and strong cross-site collaboration focused on bug fixing.

In each sprint iteration, I coordinated the resolution of complex bugs by breaking down tasks and engaging the team in planning and solution discussions. This collaborative effort significantly increased the system's stability.

As a result, the Mean Time Between Failures (MTBF) improved dramatically — from 2 months to 12 months — demonstrating the success of our quality-focused approach.

Each release was finalized through close collaboration with Product Owners and based on continuous customer feedback. The release plan was frequently redefined according to project-specific priorities and regional requirements.

Releases were often scoped per project and geographic target, such as Europe or Asia, focusing on region-specific features and hardware. New functionalities were validated through pre-release versions deployed exclusively on Schindler test towers, ensuring alignment with customer expectations and real-world scenarios.

Implemented a remote connection to the elevator system for real-time operation monitoring and diagnostics. Enabled event logging prior to critical failures (e.g., installation freeze) to support root cause analysis.

By capturing the sequence of events leading up to fatal errors, we successfully identified and resolved several complex issues — not all of them software-related!