Brandon Ducci

Lead backend enterprise developer tasked with redesigning as well as modernizing a low code, RPA legacy system called Collaborator that was created in the late 90's. In addition I also had to add new features to the new application.

Development:

• Created a new application in .NET 8 that will be used to redesign and modernize a large legacy system.

• Designed the application to center around hexagonal architecture as well as a modular monolith. This resulted in all components being very isolated and decoupled. Each API module contained its own configuration files which offers us the flexibility of pointing a module to whichever database we desire i.e. point each module to its own dedicated database or to a shared database. This architectural style also allows us to debug the codebase as a single application but offers us the flexibility of deploying each module as its own independent application.

• I created a solution structure that split the solution into three folder categories namely the business core, technology and tests. In the business core category, business logic was represented as features each as its own project. The technology folder contained all the technology we used each as its own project e.g. EF core, ObjectMapper , API and so forth. The tests folder contained test projects that tests the business core as well as perform architectural tests to ensure design and standards are followed.

• API's were designed using the REST architectural style in ASP.NET Core. Each API project utilized the IOC framework in ASP.NET Core to create and manage dependencies. API request middleware was utilized which hooks into the API request pipeline in order to centralize the handling of exceptions, authorizations, rate limiting and so forth.

• The entire legacy database was converted to Entity Framework Core using the database first approach. The system was designed to separate business from technology. As such the entities in the business layer are separated from the EF core entities and as such mappings occur to translate the business entity into an EF core entity that is used to interact with the database.

• Focused on designing features in a way that adheres to SOLID principles as well as ensuring that the services depend on abstractions so that the features are easy to test, maintain, can utilize dependency injection and offers flexibility in swapping out different implementations. The Open closed principle was utilized heavily to ensure we only ever append to the code base instead of modifying the existing code. Existing code was only modified if a clear and obvious bug was present.

• Since this is a legacy system that is getting redesigned and modernized in a new application, I had to utilize DLLs where appropriate to take advantage of legacy code where necessary. This also required ensuring that the relevant Nuget packages are loaded and still compatible with the legacy DLL. Created program to analyse DLL assemblies to determine dependencies and compatibility issues.

• Performed performance checks to determine where services are slow. Investigated what was causing the performance issues and rectified them. For example, there was poor performance in EF core due to how the framework was designed when saving changes to the database. After investigating what was causing the issue I rectified the issue through changing settings on EF core and this dramatically improved performance.

• Deployed each API project to IIS as its own independent application after each feature has been completed.

• In addition to the task of redesigning and modernizing this legacy system I also had to add new features to the new application. I had to create a feature which allows us to create virtual objects whose data and structure is obtained from an external system. In this specific case we wanted to add objects from the Phoenix financial system into the Collaborator system so that these external objects could be used to kick off workflows and so forth within the collaborator solution.

Technologies used:

• .NET 8.
• ASP.NET Core Web API.
• Entity framework Core.
• AutoMapper.
• Sql server.
• JSON.
• XML.
• ASP.NET Core IOC framework.
• C# Expression trees, LINQ, Generics, interfaces, classes, collections and so forth.
• Nunit.
• IIS.

• Performed a role as a Senior Software Engineer consultant. Completed computer vision project in Python as well as assisting SITA with bugs in their web application.

• Formed part of the .NET development team responsible for implementing development features for the AJS accounting and legal software solution.

• Worked within two week sprint cycles to implement development features.

• Utilized C#, AngualrJS, CSS and HTML technologies for feature development.

• Implemented hexagonal architecture for development features.

• Followed test driven development where possible utilizing the NUnit framework.

• The AJS accounting and legal software solution is a web application that involved creating and working with a lot of Web API's, Modules, views and controllers.

• Worked on various features but more notably, incorporated the bank account verification service feature into the AJS solution.

Extensively involved in the development and support of SAP ERP applications run by hundreds of customers world wide. The two most well-known products that I have been involved with are Query Manager which is well known for being a HCM reporting software solution as well as Data Sync Manager which copies data across the SAP Landscape.

ABAP development experience:

• Created multiple programs to enhance our products.

• Produced well structured, maintainable and efficient coding solutions in order to satisfy the needs of our customers as well as make it easy for developers to support.

• Exposure to various SAP HCM areas i.e Payroll, wage types, various PA and HRP tables and transactions.

• Created business objects and data sources to widen the scope of our reporting software. This included both on premise objects within the scope of the SAP ERP system as well as external systems like SuccessFactors where I had to create recruiting objects and employee central objects via the ABAP language to allow customers to report on these within our reporting software.

• Integrated with SuccessFactors in order to offer additional reporting features within our on-premise reporting software.

• Refactored code where required to improve the overall maintainability and extensibility of the solution.

• Creation of classes, data structures, DB tables and all the usual repository objects required to create a solution.

• Creation of OData services, Function modules, User exits, transformation functions and RFC's which were used within the solution.

• Producing and consuming JSON, XML and API's.

• Creation of numerous patches for customer defects logged.

• These patches covered a vast range of problems spanning the entire code base of our solution i.e Defects ranging from front end issues, middle layer issues, engine issues and even on occasion library issues.

• Extensive debugging of the SAP standard in order to better understand the functionality and integrate this into our reporting software solution..

Support experience:

• Extensive amount of debugging experience both in support and development.

• Numerous debug runs to find the root causes of issues and debug the problem from various angles. It was important to correctly identify the root cause of an issue and ensure this is addressed.

• Numerous amount of customer calls where we require access to their system to investigate the issues they are facing with the solution. This required thorough investigation, problem solving and clear communication to non-technical customers who operate at a different vocabulary and area of expertise.

• Countless patches created to address defects within our product.

Testing experience:

• Thorough testing of the ABAP solutions I have created both for new developments as well as patches for defects logged by customers.

• This required testing the solution from multiple angles such as stress tests, unit tests, debugging the solution line for line to ensure the correct state is being observed, attempting to break the solution, creating data to test the solution with different types of data and so forth.

• Using various tools to test the state of the development solution i.e Performance tests, database traces, code quality checks and various other tools to ensure the quality of the development solution is up to standard.

Documentation experience:

• Produce functional documents describing how a piece of functionality works so that we can successfully integrate this into our SAP on premise solutions. For example, documenting how SuccessFactors works in various areas such as how certain business logic works, transactions and so forth so that I can effectively implement a technical implementation that integrates with our SAP on premise reporting solution to allow customers to report on SuccessFactors data.

• Produce technical documents depicting the planned architecture of the solution which I then implemented in a coding solution.

• Produce documentation of in-product features.

• In general, once an employee produced a new feature or piece of functionality within the product they are required to write up the necessary in product documentation for this feature.

Managerial experience:

• Managed five new graduates for a period of 9 months.

• Managed their work load and assisted them where necessary. This included both their support function as well as their development function.

• Reviewed work produced by the graduates.

• Created necessary reports to effectively monitor the graduates work load and progress.

• Implemented conflict resolution measures when necessary.

• Reported back to higher management on the state of affairs regarding work items of new employees as well as any potential areas of improvement we require in our processes.

• Implemented a knowledge sharing session to improve the support function. During this session employees would essentially share what support tickets they worked on by taking us through the entire process from problem definition, investigation and the ultimate solution to the problem.

• This facilitated rapid knowledge sharing amongst the new employees and sped up their knowledge of the product as well as their ability to support the product more efficiently.