SUMMARY:

21 years of experience in Java/J2EE/C/C++ related technologies, developing multithreaded Grid - based Risk Management applications in Fixed-Income (Interest Rate) Derivatives, Munis, Muni-Indices, CCAR, CDS, Equity Derivaties; Investment Banking/Trading (Fixed Income and Equities), Wealth Management, M&A (Mergers/Acquisitions), Mortgage, Reinsurance, E-Commerce, and Time and Attendance (T/A).

TECHNICAL SKILLS:

Distributed Computing: Apache Spark, Hadoop, Symphony (Grid Computing), Kafka, Greenplum (GP)

NoSQLDatabases: HBase

RelationalDatabases: Oracle, Sybase, DB2, SQLServer, MS Access, Cloudscape

Caches: Gemfire, Coherence, Gigaspaces, Ehcache, Active Pivot (Cube)

Messaging: JMS, AMQP, Tibco EMS, Rendezvous, MQSeries, Apache MQ, RabbitMQ, Visibroker

Frameworks: Spring, Spring Boot, Aspects, AOP, Reactive Spring, iBatis/myBatis, Hibernate, Drools

WebTier/GUI: AngularJS, HTML, JavaScript, TypeScript, Json, REST, Webservices, Spring MVC, Struts

DBTools: SQLDeveloper, SQL-Plus, Toad, SQL Query Analyzer, Aqua Data Studio, DBArtisan, SQL Server Enterprise Manager

Scripting: Python, Shell sciprting (Unix/Linux)

App/Web Servers: WebLogic, Websphere, JBoss, Jetty, Tomcat, JRun, Powertier, Microsoft s IIS and PWS.

Design/UML Tools: ArgoUML, Visio, Rational Rose, TogetherJ, ObjectDomain

IDEs/Editors: Eclipse, IntelliJ, Visual Studio, JBuilder, Visual SlickEdit

SourceControl: Git, SVN, Perforce, CVS, VSS (Visual Source Safe), Teamware, PVCS

Performance/Monitoring: JProbe

Build Tools: Ant, Maven, Ivy

ReportingTools: SSRS, InetSoft s StyleReports (5/6)

Others: C/C++/C#, SOAP, JAXP (SAX/DOM), XSL/XSLT, JAXB, JAXM, JAXR

PROFESSIONAL EXPERIENCE:

Confidential, NYC

Senior Java Architect/Developer

Responsibilities:

• Confidential has a proprietary application for calculating issuer default loss for various CCAR/adhoc scenarios.
• However, the application is very poorly designed. Every time a user needs to do an adhoc loss simulation specifying custom calculation parameters, a configuration needs to be created manually. Biggest drawback is that the entire application runs in a single-thread, taking a very long time. Configuration is all over the place. Even a simple change requires hours of effort to carefully make the change at a lot of places (database functions, configurations, application-code)
• I am responsible for redesigned the application to improve performance, make it more easier to use (especially for user-defined adhoc loss calculation scenarios). Besides the core proprietary loss calculation logic, everything else will be required to be written from scratch. Current application has too much dependency on database functions, making it very hard to debug/enhance/improve performance. Moreover, it is not correct either, given the amount of data the application has to process. All that logic will be moved out into smaller reusable components that support quick turnaround for future enhancements.

Environment: /Tools: Java 8, Spring Boot/JPA, Maven/Ivy, Greenplum (GP), DB2, Python.

Confidential, NYC

Senior Java Architect/Developer

Responsibilities:

• Confidential need a Global platform for Risk Managers to monitor market and credit risk.
• Each risk team does real-time valuation for its own desk, feeding risk to their own UI. However, there is no common/single platform for Global Risk Managers to monitor the credit/market risk.
• I am the main architect to design the system that aggregates data/risk from various source systems and monitors it.
• Complex monitoring rules are run at various levels (Region, Desk, PL-Hierarchy, etc.) at configurable granularities (Issuer, Currency, etc.) and measures (Equity-Delta, FX-Delta, Tenor-Risk, Vega, etc.).
• System is designed as multiple independent server side components that run as separate processes, communicating via cache-api (continuous queries provided by Gemfire and Active Pivot), and Tibco/EMS.
• Source systems provide data at lowest possible granularity (book for market risk, trading-account for credit-risk). This data is enriched with -data and stored in in-memory Gemfire cache. The data is then pushed into a Cube (Active Pivot) for users (as well as monitoring logic) to slice and dice it as per their needs. Due to the nature and volume of data that needs to be aggregated and then monitored, the monitoring logic runs as near real-time (making it true real-time is a challenge that cannot be achieved without using cloud, which is out of scope for the project).
• I am also responsible for the majority of common monitoring modules, including data access layer (database, cube/mdx), generate and run mdx-queries across all the cubes, capture results, and run breach rules for all limits.

Environment: /Tools: Java 8, Spring Boot/JPA, Maven, Gemfire, Active-Pivot/Mdx, Continuous Queries (CQ), Sybase, Tibco/EMS, Bamboo.

Confidential, NYC

Senior Java/Grid Developer

Responsibilities:

• It is used by Portfolio Managers to manage their risk, do risk/scenario simulations, generate reports (Returns analysis, Portfolio Attribution, etc).
• However, this application cannot scale (daily risk calculations take a lot of time, scenario calculations freeze the GUI, and other performance issues).
• A rewrite of the entire application is being planned.
• Responsible for analyzing the existing code for various modules - like market-data-capture (to capture all market artefacts like prices, curves, vols - including all the curve fitting algorithms (both common, and propiertery), and pricing modules for various currency futures, bonds, and mortgages.
• The rewrite will involve coming up with a cloud based architecture (Spring Cloud, Kafka, etc).

Environment: /Tools: Java 8, Maven, Angular4, Oracle, Sybase, MySQL, Spring Boot, Spring Cloud/Spark, Kafka, Tidal, Apache Activiti

Confidential, NJ

Java/Grid Developer

Responsibilities:

• Calculation jobs are submitted to a job manager queue - a priority queue that orders jobs as per certain rules. Jobs can either request fixed or variable number of compute cores.
• They may have pre-calculation steps like pushing the software and/or data to the compute nodes, and may also need the input data to be broken down into smaller chunks.
• They may also have post calculation steps, like aggregation, persistence, etc.
• The orchestration module manages the tasks for all the jobs currently in progress.
• Depending on various factors (job profile, priority, etc), currently executing job may see a redistribution of compute cores and/or frequency at which tasks get scheduled.
• These distributed components use JMS and restful services to communicate with each other
• Primarily responsible for provisioning module which manages how multiple requests for compute cores are satisfied, and also responsible for the orchestration logic that dynamically allocates/deallocates cores as necessary.

Environment: /Tools: Java 8, Ant, Spring/AOP, Spark, Hadoop, Azure, AngularJS, Apache Activiti, Coherence, Oracle, Weblogic, Tomcat.

Confidential, NYC

Senior Java Developer

Responsibilities:

• Non-Purpose Lending business caters to High Confidential Clients who want to borrow money against their investment portfolios.
• Confidential (Field Advisors) use Loan Origination app (written in AngularJS/JSON/Java/DB2 hosted on Jetty) to initiate the loan requests, using client’s investment portfolios (and other assets) as collateral. The loan application then moves through various phases, under complex workflows (Drools), executed by multiple apps that coordinate with each other using JMS (MQ Series) and Webservices/JSON.
• Responsible for design/development/testing of various web-pages, and frameworks (security/entitlements, messaging, batch), spread across various apps (AngularJS/Java, messaging, webservices). Most of the non-business logic (logging, security, transactions, etc) and some core business logic (business and workflow context) was developed as Aspects (AOP proxies) to guarantee properly controlled execution of the main business logic.

Evironment/Tools: Java 7/8, AngularJS, Drools, Jetty, MQSeries, DB2, Webserives/JSON, Spring/AOP, Ant/Ivy, Eclipse, Perforce, Python, Linux.

Confidential, NYC

Lead Java/J2EE/C++, Symphony-Grid Developer/Architect

Responsibilities:

• Lead Java Developer/Architect for Grid based Risk Management System
• Muni derivative trading/risk-management division in Citi takes positions in municipal-bonds and interest-rate products like various types of IR swaps (e.g., vanilla 1/3/6-month Libor, constant-maturity, TRS, BMA swaps, etc), rate-locks, caps/floors, swaptions, mortage-service rights, etc. Developed application to help risk managers keep a check on risks associated with these positions
• Application does various (EndOfDay/Live/Adhoc) calcualtions, like PV, Greeks - mostly 1st order, like Deltas for various curves (Libor, BMA, Fedfund, and Minor-market), Vega, Rho, and a few 2nd order, like Gamma, along with stress calculations for CCAR
• Once all the calculations are done, application then generates various reports based on config, like PAA, PnL, Trade-Activity, etc
• To do all these calculations in an efficient/optimal way, the application makes heave use of Symphony Grid.
• All the calculations are run on the grid. Other server-side components handle other light tasks like capturing trades/positions, market-artifacts (Curves, Resets, and Vols).
• Application has various front-ends like, excel-plugin, webpages (including dynamic/ajax html), and other applications
• All these front-end clients are served via webservices (server can handle many data exchange formats like json, xml, html, csv, txt). Core server side is made up of mulithreaded distributed java components, which interact via EMS messaging.
• Worked closely with business and quant team, to create analytical representation for all kinds of securities/products, including any new products that business wanted to create and trade in; and calculations to be done on them (involves bumping the pricing environments for various stress scenarios).
• Other major contributions included developing frameworks (database persistence, parallel execution of tasks within same jvm or on grid)
• Played key role in helping junior developers get on board, and constantly provide them technical help/mentoring, so that they can work independently to implement required functionalities in timely manner.
• Also worked closely with business in defining several new Muni Indices by various criteria like High Grade, High Yield, sector indices (by industry, etc); and run daily calculations, like total-return (along with its components like accrual return, principal return, etc), results of which were made available to external clients via CitiVelocity.

Evironment/Tools: Java 6/7, C++, Symphony-Grid, Tibco-EMS, Weblogic, Webserives/JSON/Websockets, Spring, iBatis/mybatis, Ant, Maven, Eclipse, SVN, Autosys, UNIX/Linux shell/perl/python scripts, Oracle, Sybase, MS-SQL (SQLDeveloper, DBVisualizer), SSRS Reporting.

Confidential, NYC

Senior/Lead Java/C++ Consultant

Responsibilities:

• Lead Java/C++ Developer/Architect for Spring/iBatis based applications.
• Senior Java/J2EE programmer (Multi-threaded applications)
• Equity Linked Technology group has a suite of applications for the equity-derivatives business of Merrill-Lynch. Designed/developed server-side frameworks/components for capturing/calculating various Risk Measures (alpha, beta, gamma, volatility) and the daily P/L. For the end-of-day applications (batch), the calculation results along with other critical data like transactions and position-summaries were captured in the database using applications that ran multiple-levels of parallel-threads. This data was then used to generate reports.
• The configurable framework had some similarities with Hadoop. Pluggable tasks could be defined, and added to the flow for sequential or parallel execution via xml-configuration. Framework could handle multiple (nested) levels of parallel execution. This helped making real-time calculations a possibility.
• Reporting framework helped other team members add reports using Spring/iBatis configuration, and greatly improved the reporting performance (entire batch-cycle saw more than 40% overall performance improvement - reducing the overnight calculation and reporting process to a few hours).
• Other responsibilities included regular production support and mentoring the junior developers (helping them create xml configurations and batch/reporting modules).

Environment: /Tools: JDK5, Spring, iBatis, Maven, Eclipse (3.3+), SVN, Autosys, UNIX shell/perl scripts, Tomcat, Linux, Windows, Oracle

Confidential, NYC

Technical Lead/Developer

Responsibilities:

• Real-time CDS Trade Processing (Quant/Analytics) for Risk Management
• Worked on risk management application to manage the bank’s positions and risk for various fixed income products, like bonds, loans, private equities, credit default swaps (CDS) and other fixed-income derivatives (tranches, baskets). Risk managers use this application to control the bank’s exposure for the issuers of these fixed-income securities, and advice the appropriate personal (Traders and Portfolio Managers) on how to limit the risk on these issuers (within a portfolio and at other levels - desk, department, business-group). The application can present the data sliced and diced at various hierarchies.
• Primary responsibilities were to capture the CDS trades (Single Name and Index, including CDS on loans), calculate various analytics/sensitivities like PV, CS01/DV01, IR01, etc and then update the positions accordingly. This enabled risk managers to see how the risk is changing during the day and put appropriate checks in place, like ensure that traders are not betting too much on the credit quality of an issuer (by selling too many CDS), and are hedging the existing bond positions by buying appropriate CDS protection. Basically, ensuring that the risk/positions are in line with the business goals.
• Other responsibilities included writing various server-side services/frameworks like Gigsspaces (caching/messaging), database access, JMX management beans, JMS messaging. Also maintained build and deployment scripts for all the modules.
• Regularly mentored junior developers

Tools: used: JDK5, Tomcat 5, Tibco EMS, Hibernate, Spring, Ant, Gigaspaces, Eclipse (3.2), Weblogic (8.1, 9), Perforce, Autosys, UNIX shell scripts, FpML, UNIX (Sun Solaris), Windows 2000, Sybase (11, 12), Agile Development

Confidential, Warren, NJ

Senior Java/C++ Developer/Architect

Responsibilities:

• Confidential ’s Client-Connectivity group provides FIX-connectivity to Confidential ’s global clients (Financial Institutions). Based on customer profiles, the incoming orders are routed either to the downstream trading systems or sent directly to the market (DMA/Algorithmic Trading/LAVA). The FIX-connectivity is provided using in-house FIX-engines and TransactTools (TCM 4/5). The IOI/AT (Indications of Interests/Advertised Trades) application allows Confidential ’s traders to send pre-trade (IOI) and post-trade (AT) messages to its trading-partners - various clients and vendors like Bloomberg, Autex (Thompson Financials), Bridge (Reuters), Fidelity and Putnam. The IOI/AT application consisted of core server-side components that accepts outgoing IOI messages from various sources (IOI GUI and other trading systems) and then sends them to external clients over FIX.
• Enhanced the IOI applications to tier the IOIs (split an IOI into more than one), with different tiers representing different percentage and price of the original IOIs. Preferred (high-profile) clients in upper tiers receive better IOI price and shares, than the ones in lower tiers. This stopped a less favored subscriber (which usually does business in small quantities of shares) to take advantage of the price meant for a subscriber who does business in big quantities and less commission). The more favored subscriber gets to see the original quantity and price of the shares, while a less favored subscriber would see a smaller than original quantity.
• Added failover capabilities for the entire IOI server-components using Veritas. This minimized the down-time due to Hardware/IP/Disk/Process failures by automating the entire failover process. The only delay that the clients of the server-modules (brokers using the desktop IOI applications and the external FIX-customers) would see is the time it takes for applications to restart.
• IOI/AT application was a legacy C/C++ client-server application. Did the architecture, design and prototype for rewriting the application to build the next generation robust, scalable, multi-threaded application using Java, Tibco-EMS as the JMS-broker and TransactTools as the FIX-connectivity tool.