Served as 1 man front end development team to build new client software using Angular 7 and using DevExtreme libraries. Designed UX/UI, wired to back end REST resources, and provided deployment guidelines for DevOpsteam.

Spent time daily with junior developers, mentoring them in best practices for java development, to include guiding them throughbest practices in application setup, class design, coding techniques, documentation, and code review. I also spent time with Architecture Teamdesigning software to support integrations of existing systems with new Cloud Based technologies as the company expanded to international markets.

Participated as SCRUM Master and Team Member. This application was an integration project responsible for integrating both custom, and 3rd party applications, while introducing a new development Framework for the company.

• Built user interface using legacy WebLogic 10.3 Workshop.
  • Provided security using Custom Self Service application and RSA (Cleartrust)
  • Refactored POJO beans into EJB 2 specific Session Beans.
  • Designed and built custom Email application using EJB’s (MDB) and JMS.
• Designed and built Rest based Service to run on JBoss 6.0 server
  • Leveraged provider Pattern to allow for service to dynamically interact with Different services such as RSA and ACI (Wire Transfer Application).
  • Refactored POJO beans as EJB 3 specific Session Beans
  • Integrated Hibernate into Service layer to manage Database interactions.
  • Build interface for Selenium tests to be run against Service layer.
• Built Jenkins jobs to manage both the client and service applications developed.
• Build Session beans and MDB’s using Eclipse Juno and WebLogic Workshop 10.3.
• Leveraged XML Beans to manage Enterprise data schema.
• Used Hibernate 4 for database Persistence to an Oracle and Sybase database
• Used SVN for Version Control and Jenkins for Continuous Integration.
• Used Version1 heavily to manage team tasks along with MAVEN to manage Builds, Utilized JUNIT as the Unit Test Framework.

Served as SCRUM Team member to provide guidance to team on System and Application Architecture in creating a complex multi-threaded, multi-tiered, Message driven application that listens for JMS Messages on a Tibco Service Bus and performed transaction driven data base updates to Patron records for database containing over 50 million records.

• Provided a Batch Import Framework to allow affiliates to upload Patron updates via a batch file.
  • Imported and parsed files from remote locations for individual information.
  • Interpreted details from files and populated data model built by JAXB.
  • Pre-processed files for validity before sending to bank for updating.
  • Heavily utilized Factory Patterns to create appropriate objects for Batch Import Framework.
• Designed and built Message Driven EJB’s for the Bank Service to provide Import functionality. Refactored 3 other MDB’s to allow Import MDB to leverage existing services.
  • Pushed logic down from MDB’s into Process level classes. Transitioned the Hibernate Entity Manager that used JTA persistence into NON JTA Persistence units to provide Bean Managed Persistence (BMP) instead of Container Managed Persistence (CMP)
  • Defined Transactional boundaries of refactored classes to allow for Exceptions to be bubbled up to the Service method and handled appropriately without ending Transactions
  • Ensured data integrity by building preprocessing validation methods that were executed before the Processing of the transaction.
• Built a customer Task Queue Service wrapper for the WebSphere Task Manager to provide a common framework for executing Runnable objects on a separate managed thread.
• Helped to design a Customer Unified Testing Framework that tested data integrity from Transactions, transaction processing accuracy, and different JMS scenarios.
• Build and managed MDB’s using Eclipse Juno and WebSphere 7.
• Leveraged JAXB to managed Data Model Schema.
• Used Hibernate 4 for database Persistence to an Informix 10 database
• Used SVN for Version Control and Jenkins for Continuous Integration.
• Used JIRA heavily to manage team tasks along with MAVEN to manage Builds, Utilized JUNIT as the Unit Test Framework.

• Provided a management interface as well as a remote server interface to allow for distributed processing on remote sites.
  • Custom built administrative interface for user to define customer hierarchy (Customer, Sites, Servers, Processes, and Resources), configure each item as needed, and control items in the hierarchy when required.
  • Used custom built protocol using SFTP to manage remote systems behind firewalls using JCIFS.
  • Leveraged a customer built “heartbeat” to provide for status of remote components (Server, Process, and Resources).
• Provided custom designed workflow interface to graphically layout work flow components and describe how terabytes of content was moved from Customer site to Nexidia.
  • Used over 20 custom built plug and play components in the workflow interface. These components were used to query databases (JDBC), identify media, analyze the media (NIA Workbench), move the media (JCIFS), extract metadata (OPENZIP, OPENCVS), and transform media and files to appropriate format (GSON).
  • Analyzed media files to look for duplicate content, language of media files, and blank spots in media files.
  • Reported runtime statistics for analysis of process performance and to allow the user to graphically see where the errors occurred during processing files.
• Provided alerting system to allow for remote servers to send alerts to designated administrators upon encountering an Error, or when a defined error threshold had been exceeded.
• Build and managed user interface using Eclipse Juno and Glassfish 4.0.
• Leveraged jQuery 1.7.2, jqWidgets, and JSPlumb to build all interfaces.
• Leveraged GSON to transform objects to JSON for communication to Web Interface.
• Leveraged an Event Driven design to manage all interactions with the server.
• Used Eclipse Link JPA for database Persistence to a PostGres 9.2 database
• Leveraged JUnit and Mochito to build unit tests
• Heavily leveraged the Java Executor Service and the Java Timer Task facility.
• Used SVN for Version Control and Bamboo for Continuous Integration

• Provided users a quick way to view uploaded reports in a tabbed interface.
• Provided report management using an accordion style menu system.
• Provided administration interface to allow report producers to upload reports.
• Provided the ability to sort reports based upon user “favorites”, (instance, series, or category favorites) or the most recently update reports available.
• Provided the ability to search through reports based upon report meta-data and quickly view other reports.
• Managed relationship with a remote development team to provide external development of well-defined deliverables. Responsible for overall coordination, requirements definition and analysis, and delivery of product
• Build and managed user interface using Eclipse Juno.
• Leveraged jQuery 1.7.2. Specifically, used accordion, and scrollable tabs.
• Communicated to the server using AJAX only.
• Used a single servlet to act as front end controller.
• Leveraged an Event Driven design to manage all interactions with the server. Used Spring 4 to manage event handlers and provide scoping for all Spring Beans.
• Integrated web security with 2 different security providers based upon the device.
• Browser based users were integrated into the CSP and External gateway that provided an authentication services via a cookie-based algorithm
• Device users were integrated into the EDS Gateway that provided an authentication services via a header-based algorithm.
• Built application persistence model using Hibernate that reflected the domain model.
• Built an in-memory process subsystem to receive uploaded PDF files, turn them into images and stored them as BLOBs in the database.
• Persisted all data in an Oracle 11g database. Designed and implemented database structure leveraging triggers and stored procedures where needed.

Responsible for creating all Architecture Models required for acceptance through Architecture 1 and Architecture 2 toll gates (CHEF Methodology). The list of artifacts required include Business Domain Model, Application Domain Model, Component Models for each system, Deployment Model for each system. Models were built for both AWS and Azure deployment. Designed Digital Identity platform using AWS Cognito. Planned out day to day development activities to build Enterprise Services layer. Planned, designed, and developed strategies for integrating external systems into Enterprise Services Layer.