Vlad Hryhorenko

Bottomline Technologies, Inc (Legal-X project).
The project involved migrating a legacy code base to a modern stack for an application aimed at facilitating documentation exchange among legal vendors.
Professional responsibilities:
- designed RESTful APIs following OpenAPI specifications and comprehensively documented them to ensure clarity and ease of integration for stakeholders;
- led the implementation of contract tests using Spring Cloud Contract to ensure compatibility and reliability between microservices, reducing integration risks during upgrades and deployments;
- implemented robust security measures using Spring Security and Keycloak, configuring fine-grained
authorization policies based on user roles to ensure secure access to application resources;
- orchestrated the integration of Keycloak as the authentication server for seamless SSO experiences and integrated Okta as an Identity Provider (IdP) for federated authentication, simplifying user identity management across systems;
- managed application deployments using Helm charts, ensuring consistency and reproducibility across environments for streamlined deployment processes;
- contributed to DevOps practices, including infrastructure as code (IaC) and containerization, leveraging GitOps principles to foster automation and efficiency within the team;
- utilized Bamboo for CI/CD automation and pipeline orchestration, accelerating the software delivery process and enhancing time to market;
- leveraged Spring Boot's relaxed data binding to automatically map Vault secrets to Spring application properties, simplifying configuration management and reducing development complexity.

Amdocs-Openet (5G Telecommunication).
The team is supporting, managing and developing Policy Control Function (PCF) that is a critical component within the 5G network architecture which plays a key role in managing and enforcing policy rules for various network services and subscriber interactions.
Professional Responsibilities:
- spearheaded the creation and enhancement of key features within a suite of microservices, pivotal to the seamless execution of policy rules throughout the entire 5G session lifecycle;
- demonstrated expertise in setting up Windows Subsystem for Linux (WSL) images from the ground up, showcasing a deep understanding of virtualized environments and cross-platform configurations.
Proficiently managed and debugged a multi-container application using docker-compose, adeptly navigating diverse environments, including remote debugging connections to virtual machines (VMs), to ensure robust application performance;
- orchestrated the seamless integration of microservices through an event-driven design approach using Apache Kafka streamers, facilitating real-time communication and data flow across the ecosystem;
- exhibited adeptness in Kubernetes deployment strategies, leveraging helm chart configurations to streamline the deployment process, optimize resource utilization, and enhance application scalability;
- played a pivotal role in maintaining system integrity by meticulously applying patches and fixes to various release versions, employing diverse Git strategies and Jenkins pipelines to ensure continuous stability and functionality;
- drove end-to-end feature development and delivery, from conception to implementation, showcasing proficiency in full-stack technologies including Angular, Typescript, and Java. This comprehensive skill set enabled the creation of cohesive and impactful features that enriched the user experience.

Nordstrom (CCPA)
Help Nordstrom address regulatory challenges related to the introduction of CCPA and similar acts in US and Canada.
Responsibility for centralized processing of all customer communication messages (emails. texts, push notifications).
The main challenge is being able to take over a number of different work streams at once.
Personal responsibilities:
- building Message Brokers using AWS Queues (Including Deadletter Queues) and Apache Camel: designed and implemented resilient message brokers utilizing AWS Queues, with a particular focus on reliability and scalability, incorporated Apache Camel to apply Enterprise Integration Patterns, ensuring efficient and standardized communication between systems, configured deadletter queues to capture and analyze failed messages, enhancing error handling and troubleshooting processes;
- migrating Distributed Log System from AWS Kinesis to Apache Kafka: spearheaded the migration project, transitioning from AWS Kinesis to Apache Kafka to improve data streaming and processing capabilities,
orchestrated a seamless migration plan, minimizing downtime and data loss while optimizing system performance.
- building Serverless Components with AWS Lambdas: designed and developed serverless components within the application architecture using AWS Lambda functions, implemented Lambda functions for diverse tasks, such as log collection and transmission from AWS CloudWatch to Splunk, enhancing monitoring and log management efficiency.
- managing Blue-Green Deployment with AWS LoadBalancer: took charge of the blue-green deployment process, ensuring smooth and fault-tolerant application updates, leveraged AWS LoadBalancer to seamlessly shift traffic between old and new application versions, reducing deployment risks and minimizing user impact.

- writing Integration and Unit Tests using TDD Approach: developed comprehensive test suites that covered both integration and unit testing for various software components, ensured that test cases encompassed critical functionality and edge cases to catch potential issues early in the development cycle, designed and implemented integration tests to validate the interaction between different modules and services within the application;
- PagerDuty On-Call Support and Just-in-Time System Support: provided critical support as part of the PagerDuty on-call team, guaranteeing the continuous operation and reliability of essential systems, responded to just-in-time system issues promptly, minimizing downtime and mitigating potential disruptions to business operations.

Social game "Travel Rush" project.

Personal responsibilities:

- EFK Stack Deployment on AWS EKS using Helm Templates with an Istio Operator as a Service Mesh: orchestrated the deployment of the ElasticSearch-Fluentd-Kibana (EFK) stack on AWS Elastic Kubernetes Service (EKS) using Helm charts; integrated Istio as a service mesh into the Kubernetes cluster to enhance observability, security, and traffic management, ensured efficient log aggregation, analysis, and visualization by configuring Fluentd to forward logs to ElasticSearch and presenting them through Kibana dashboards;
- Kubernetes Cluster Version Upgrade using Failover Approach: managed Kubernetes cluster version upgrades by following a failover approach, minimizing service disruptions; created NodeGroups to smoothly transition worker nodes to the new Kubernetes version while maintaining workload availability; ensured data persistence during the upgrade by utilizing Persistent Volume Claims (PVCs) to maintain critical data across node replacements.
- Spring Boot Microservice Application Development: Event-Driven Design with MongoDB Observers-Listeners, In-Memory Data Storage Usage, Conditional-on-Bean Approach Implementation: designed and developed Spring Boot microservices following an event-driven architecture, implemented MongoDB observers and listeners to react to changes in the database, enabling real-time updates and data synchronization; utilized in-memory data storage for caching frequently accessed information, improving application performance; leveraged Spring's conditional-on-bean approach to configure and conditionally load beans based on specific conditions or dependencies, ensuring modular and efficient application configuration.
- Script MongoDB Data Migration: created and executed scripts for MongoDB data migration, facilitating the seamless transfer of data between different database versions or structures; ensured data integrity and consistency during the migration process while minimizing downtime or data loss.
- Gradle Application Assembling: managed the assembly and build process of applications using the Gradle build tool; configured Gradle build scripts to define dependencies, build tasks, and custom assembly processes; ensured consistent and efficient application packaging and distribution.

Interactive, movie-based, being developed by creative team project. The main
idea is about creating viewers-actors conversational theater, where spectators
can choose a way the actors have to go through.
Web application has three main parts: the first - spectators choose actions
using their own devices, the second - admin rules the show (regarding viewers
preferences), the third - polling on the big screen.
Personal responsibilities:
- Spring MVC Pattern Integration: integrated the Spring Model-View-Controller (MVC) pattern into software projects, providing a structured and modular approach to building web applications; utilized Spring MVC to design and implement the application's user interface, manage user requests, and handle server responses; leveraged Spring's powerful features like controllers, views, and models to create dynamic and responsive web applications.
- creating Spring Boot App Using WebSockets Protocol: developed Spring Boot applications that leverage the WebSocket protocol for real-time, bidirectional communication between the server and clients; implemented WebSocket endpoints and message handling to enable features such as chat applications, live notifications, and collaborative tools, ensured efficient and low-latency communication by utilizing Spring's WebSocket support.
- i18n and l10n Concept Realization: implemented internationalization (i18n) and localization (l10n) concepts in software projects to support multiple languages and regions; utilized resource bundles, properties files, or other localization mechanisms to provide translated content for different locales; designed user interfaces that dynamically adapt to users' language and cultural preferences, enhancing user experience and accessibility.
- Proof of Concept, Spikes making, Bugfixing: conducted proof of concept (PoC) projects to validate the feasibility of new technologies, frameworks, or architectural approaches; created spikes to explore potential solutions and address technical uncertainties before committing to full-scale development; played a key role in bug fixing and troubleshooting, identifying and resolving issues to improve software reliability and performance.

Worked under the project which goal was to create an application for all platforms
(Android, IOS, WEB), that would count a salary for employees of definite company
using different criteria (enter-exit time, reasons of absence, etc).
Personal responsibilities:
- server Logic Implementation: implemented server-side logic to handle client requests and business processes effectively; developed the core functionality of web applications, ensuring data processing, user authentication, and application workflows were robust and efficient; designed and optimized algorithms and data structures to meet performance and scalability requirements.
- putting-getting data to-from Database (DB): established seamless communication between the web application and a relational or NoSQL database; created data access layers using frameworks such as Hibernate, JPA, or JDBC to perform CRUD operations; ensured data integrity, security, and performance in database interactions.
- JSP and Servlets Creation: developed Java Server Pages (JSP) to generate dynamic web content on the server-side, created Servlets to handle HTTP requests and responses, managing the application's control flow, integrated JSP and Servlets to build interactive web pages, delivering a dynamic and responsive user experience.
- creating Responsive Web Pages, Using Thymeleaf as a Part of MVC: implemented responsive web design principles to ensure optimal user experiences across various devices and screen sizes; utilized Thymeleaf as a templating engine within the Model-View-Controller (MVC) architecture; leveraged Thymeleaf's features to seamlessly integrate server-side data into HTML templates, enhancing the dynamic rendering of web pages.
- bug fixing and issue resolution: played a crucial role in identifying, diagnosing, and resolving software defects and issues; conducted thorough debugging sessions to isolate the root causes of problems and applied fixes promptly; collaborated with cross-functional teams to ensure that issues were resolved and tested before release.