Gaston Mulisanga

Backend Development

• Model-Based Systems Engineering (MBSE) application:
• An automated capability system. Incorporating Continuous Integration (CI), and Automated Test and Analysis for the client’s mission critical systems on navy shipyard.
• Task (1)
• Problem (Race Condition) - The applications frontend UI status monitor was displaying inaccurate tasks progress(s) of some operations. These discrepancies were caused by the backend threads executions that monitor operations statuses not synchronizing with each other.
• Solution (Fix thread synchronization): Replicated the error locally and concluded that the application was facing thread synchronization issues (lack of synchronization and shared memory). The order of task execution did not match with its corresponding status. Introducing thread pool to facilitate the coordination of thread execution resolved the issue which allowed the status bar in the frontend UI to accurately display the progress of work completion.
• Result: By Resolving the race condition problem, there was noticeable performance improvement responses in the application UI and better data accuracy outputs.
• The feedback from the Customer was positive after resolving multitasking workload in the application. After noticing how responsive the application became and they highly encouraged the team do introduce multithreading to other components.
• Continuous Integration (deployment)
• Continuous Integration/Deployment: utilized helm charts to simplify the deployments of applications across different clusters (Test, dev, stage). Performed a multi-service deployment using helm charts.
• Debugging: using various tools to debug software such as fixing application defects unit test.
• Quality Gate (SonarQube): setup sonarqube in the existing Jenkins pipeline after integrating it within microservices.
• Security/Cybersecurity Team: (was moved to a new Team)
• This team was responsible for managing all the security aspect of the software systems in our program such as software defects, corrections, depreciated artifacts, lack of documentation, maintenance, overseeing improvements across our architecture and software stack. The goal was to have consistency across all our services.
• Task (2)
• Problems (security vulnerabilities): we had 20+ microservices with outdated dockers images, dependencies, and software artifacts. These presented vulnerabilities that posed risk for the applications and needed immediate resolution and fix to comply with clients’ requirements.
• Solution (Patch management)
• Update internal JFrog artifacts (dependencies, docker images, software components, builds)
• Updated docker images across 20+ services to reduce security risks.
• Redeployed the services and rescanned the applications using tools like rancher, anchor to make sure the software defects where resolved.
• Containerization: responsible for containerizing 30+ microservices to enable them to run k8 cluster on virtual machine
• Feedback: clients was satisfied with our applications were compliant with requirements
• Problem (Secure coding practices): the software systems under our program had inconsistent software coding practices. Our team faced the challenges of not having proper coding practices across the microservices that where under our management.
• Solution
• My solution was to standardizing good software practices. Such input validation, prevent SQL injection across our endpoints
• SonarQube scanning: The microservices where missing proper software scanning. My solution was to initially implement SonarQube by integrating into locally with the application then working with deployment team to integrate it in the Jenkins pipelines.
• Enhanced services through Auditing.
• Task (3)
• Security Compliance: software was missing a NIST and STIG standardization. The goal was to incorporate these compliances to adhere to the clients requirements.
• Problem: lack of centralized logging, making it difficult to analyze logs and difficult in detecting incidents
• Solution
• STIG: applied security technical implementation Guide to services across services
• NIST – 800-92, 800-53, CSF, privacy framework, RS.MI mitigation: Our services where not fully adhering to NIST protocols, I undertook the initiative to implement NIST compliance across 20 + services to ensure they complied with client requirements
• Enhanced services by adding Auditing logs to provide comprehensive security records and to track activities and usage of the services.
• Added further security to the API endpoints by validating requests, sanitizing inputs. Adding exceptional handling to service controllers
• Security misconfiguration: fixed verbose error messages that exposed such as system details and CORS configurations.
• Further unit testing to meet client requirements, minimum acceptance rate of 85%.
• Task (4)
• Problem (DevSecCops): Our situation was missing further SonarQube security scanning stages. Was tasked with Setting up Jenkins pipelines to automate deployments of services by:
• Integrate SonarQube across the microservice in our infrastructure to improve security vulnerability.
• Setting up SonarQube in the CD pipelines to automatically scan i.e. static code analysis (code smells, SQL injections, cross site scripting) of our service before deployments
• Deployed our services using Helm charts and Flux into Kubernetes clusters and sandbox environments for testing.
• Cloud: The client was interesting in consolidating their infrastructure for its hybrid setups. The solution was to integrate with Azure.
• Documentation: the team was facing lack of documentation and sharing for onboarding new engineers
• Solution: undertook the task of writing comprehensive documentation on confluence pages and kept them up to date.
• Sprint tickets: documented tickets since the clients reviewed our stories.
• Leadership: Was put in charge of taking the initiative to revamp and overhaul security parches of 30+ services that were spread across three teams and two divisions.
• Project Name: AEP Service

• Backend Development (Project Name: IPA-service)
• Standalone self-contained logistical Geospatial Application
• Collaborated with an agile team of 8 members to support project management throughout the software development lifecycle. Assisted in adapting to evolving customer requirements and project scope changes over a 3-year period. Participated in team updates to address and implement necessary changes effectively.
• Assisted clients in identifying issues with user interface and experience. Supported efforts to streamline functions and enhance usability. Collaborated with teams to implement effective solutions.
• Facilitated requirements gathering by actively participating in meetings to clarify user expectations for the end product.
• Compiled and documented tasks from meetings for inclusion in team backlog.
• Took the Responses from the user:
• Facilitated conversion of user responses into actionable sprint backlog tasks.
• Executed feasible and implementable tasks within established timelines.
• Supported team efforts in outlining project objectives and refining task details.
• The outcome was well defined and streamlined process for the who team
• Implementation/Maintenance.
• Achieved seamless integration of Angular frontend with Spring Boot backend in a logistical geospatial application. Enhanced application performance through proactive troubleshooting and optimization efforts. Improved user satisfaction by implementing intuitive design features in the interface.
• Executed backend service upgrades to align with best design practices, including transitioning to Java 11 and improving Swagger UI documentation for better readability and testing.
• Designed and implemented RESTful endpoints for efficient image and PDF document uploads, optimizing user experience within geospatial frontend application.
• Addressed critical bug fixes in production environment by analyzing OpenShift logs to ensure system stability.
• Engineered efficient methods for marshalling and unmarshalling to enhance data handling during XML to JSON conversion.
• Enhanced reliability of backend services by refactoring unit tests with JUnit4.
• Assisted team members in conducting peer reviews of MR/PR submissions. Reviewed and provided feedback on team projects to enhance quality. Supported collaborative efforts to improve overall team performance.
• Oversaw updates and enhancements of CRUD operations for geospatial data. Managed H2 database queries via REST API to facilitate post, update, delete, and retrieve processes.
• Oversaw comprehensive documentation efforts across all phases of the SDLC lifecycle. Leveraged Confluence as the primary tool for project documentation, catering to both technical and non-technical audiences. Maintained detailed records of source code to support ongoing development.

Project Name(s): Internal Transfer service, address sanitizer service

• Assisted in managing multiple responsibilities within contract framework. Supported team rotations based on skill demand to enhance project efficiency. Contributed to development of versatile skillsets across various teams.
• Refund Service Team
• Assisted in maintaining a microservice for processing refunds for retail banking customers. Supported the refinement of business logic related to refund issuance and settlement processes. Collaborated with a new team to enhance functionality and user experience.
• Facilitated bug resolution within lower environments using Spock framework.
• Unit testing: Introducing mutation testing to the microservices.
• Assisting other teams with their microservices
• Mentoring: mentored junior developers through paired programming.
• Address sanitizer Service Team
• Assisted in modernizing PNC address application using Spring Boot and Postgres database to create a scalable microservice. Collaborated with product owners and stakeholders to implement business features based on user requirements.
• Assisted in sanitizing and cleaning user-entered addresses to create valid and consistent formats. Supported validation of addresses against official databases through API integration.
• Enhanced product offerings by integrating new features and functionalities based on evolving business requirements.
• Refactored code to enhance application modularity. Supported improved error handling and exceptional handling to reduce bugs. Updated frameworks and dependencies to maintain current standards. Improved unit testing coverage for better reliability. Documented Swagger API endpoints for clear communication.
• Facilitated pair-programming sessions to accelerate junior developer onboarding.
• Frontend : refactored micro-frontEnd application.
• Internal Transfer Service Team
• Assisted in maintaining collaboration with Salesforce UI team. Supported PNC's microservice for managing internal transfers between retail customers.
• In this role, I was maintaining PNC’s microservices that was responsible for internal banking transfers between its clients and PNC refund microservice.
• Collaborated with business stakeholders to align services with dynamic compliance and regulatory requirements. Led initiatives to update service business logic rules in response to changes.
• Assisted QA team in identifying critical bugs during testing and supported efforts to resolve those issues. Modularized application components to enhance testing efficiency.
• Facilitated collaboration with cross-functional teams to troubleshoot and resolve bugs identified in QA environments.

Project Name: EGIS (enterprise Gateway and integration services)

• Govt Agency was trying to move away from MuleSoft ESB (Enterprise service Bus) to an open-source alternative to cut operation and maintenance cost. The solution was an Event driven Architecture with microservices serving different features and functionality using Spring boot application.
• Paired programming: As Jr developer, I did paired programming with senior developers on some functionalities.
• Collaboration: I worked closely with tech lead to insure I was following correct coding practices; implementing appropriate design patterns; and a consistent style wherever applicable.
• Asynchronous microservice: I developed an asynchronous microservice from the ground up to ingest records for logging “transactional” events from integrated microservices across our system and retrieving records for creating reports.
• Implemented Kafka for Event logging processing, creating log streams for different monitoring platforms such Elasticsearch and KPI boards.
• Containerization: Created a dockerized Postgres database image for running locally and in different environments (test, QA, Production). Used docker-compose and dockerfile to build and automatically insert records into the postgres database image at startup of the Docker.
• Java persistent API: Used JPA interface to develop code for inserting data into the microservice database.
• Integration: Implemented ActiveMQ as message broker to publish messages and Consume requests from other applications that the broker was integrated to.
• Marshaling: Used JAXB to map SAOP requests to java classes for processing that request and transformation of the response back from java object to xml payload.
• Developed SQL queries for accessing data to be used for generating various summary reports for the frontend reporting web app.
• Unit Testing: Used Junit to write unit and integration test for the features and functionalities I was implementing to ensure they worked as intended.
• Review: Participated in code review of other developers Tickets in the team to understand the standardization that the team was using.

Project Name: MDAS (Modernized 1 and Analytics Services)

• Joined the small agile team during the testing phase of SDLC. As a new joiner, I was tasked with doing unit testing to increase code coverage and to also familiarize myself with the codebase.
• I updated library dependencies across the five microservices our team oversaw.
• I updated JSON schema for the RESTful services.
• Paired programed with senior developers to do code refactoring before release.
• Participated in peer code reviews to understand code quality, coding patterns and consistent style used.
• To get acquainted with agile way and integrated into the team, I participated in daily standup, retrospective, introspection, sprint reviews, sprint planning to get me on involved.

Project Name: Core Banking Software

• Served as Subject Matter Expert to enhance understanding and utilization of banking software (T24) platform.
• Executed installation, customization, and troubleshooting services to enhance client satisfaction and operational efficiency.
• Engaged with clients to provide guidance on effective implementation strategies and enhance usability.
• Facilitated technology demonstrations and proof of concept trials to showcase capabilities to potential clients.
• Researched client needs and formulated tailored RFPs to enhance client engagement.
•