Senior Software Consultant (Python/FinTech)

Akhil Y

SENIOR SOFTWARE CONSULTANT

************@*******.*** 972-***-****

PROFESSIONAL SUMMARY

Senior Python Developer / Software Consultant with 10 years of experience building pricing, risk, and analytics applications for banking and healthcare organizations, including 7 years on front-office applications for Global Markets trading desks. Builds services in Python with FastAPI, pandas, NumPy, and QuantLib, and trader-facing screens in ReactJS and TypeScript over REST APIs. Delivers curve construction, bond and swap pricing, scenario risk, and surveillance analytics for traders, desk quants, market risk, and compliance. Owns releases, testing, and production support, and reviews code for other developers.

TECHNICAL SKILLS

Languages: Python, TypeScript, JavaScript, SQL

Quant & Data Libraries: pandas, NumPy, SciPy, QuantLib, statsmodels, Jupyter

Backend & APIs: FastAPI, Flask, Django, Pydantic, SQLAlchemy, REST APIs, WebSockets

Front End: ReactJS, Redux Toolkit, AG Grid

Data Stores: Oracle Database, PostgreSQL, MongoDB, ArcticDB, Redis

Messaging & Market Data: Apache Kafka, FIX Protocol, Bloomberg BLPAPI

Testing & DevOps: pytest, Jest, Docker, Kubernetes, Jenkins, GitHub Actions, Git

Monitoring & Collaboration: Prometheus, Grafana, Splunk, Jira, Confluence

PROFESSIONAL EXPERIENCE

TRUIST BANK - Dallas, TX Oct 2025 - Present

Senior Software Consultant

•Owned Python front office pricing and risk services for the bank's Global Markets fixed income desks, covering Treasuries, agency debt, corporate bonds, and interest rate swaps for traders, desk quants, and market risk. The services returned prices, DV01, and scenario P&L through REST APIs consumed by the desk's trading blotter.

•Built yield curve construction with QuantLib, bootstrapping Treasury and SOFR curves from live market quotes and storing every curve snapshot with its inputs. Any past pricing run could be reproduced from its stored snapshot.

•Developed FastAPI pricing and risk endpoints with Pydantic validation of trade and curve inputs, returning price, DV01, duration, and convexity per position. Batch endpoints priced a full book in one call instead of one request per trade.

•Built the trader blotter full stack, from the FastAPI feed to the ReactJS screen in TypeScript and AG Grid, streaming price and risk updates over WebSockets. Traders filtered and grouped the book by desk, issuer, and maturity bucket without reloading the page.

•Adopted ArcticDB for intraday curve and price history rather than relational tables, because desk quants pulled long time series straight into pandas and row-based queries were too slow for their research.

•Versioned priced trade and curve objects in MongoDB as the object database beside the relational Oracle Database books and records, so a past risk report could be rebuilt exactly from the objects it used.

•Streamed trade and market data events from Apache Kafka and execution reports over the FIX Protocol from the electronic trading venue, updating positions as fills arrived.

•Engineered scenario P&L for parallel and key-rate shocks with NumPy vectorized revaluation of the whole book. Market risk saw desk-level scenario results before the end-of-day risk run.

•Analyzed Treasury curve relative-value signals as quantitative research with desk quants in Jupyter, regressing spread changes on curve factors with statsmodels. Signals that held out of sample moved onto the desk's monitoring screen.

•Diagnosed prices that differed from the official close, traced to bonds priced off a curve snapshot taken before the closing marks were published. End-of-day pricing now waits for the closing curve, and the affected positions were repriced.

•Resolved blotter freezes during volatile sessions, caused by the screen re-rendering the full grid on every tick. Batched transaction updates in AG Grid kept the blotter responsive through the busiest hours.

•Developed trade surveillance checks with compliance for spoofing and layering patterns in desk order data, flagging clusters of cancellations around executions for review. Compliance reviewers got the order sequence with each alert instead of raw logs.

•Wrote pytest suites for pricing functions against golden prices from the desk's reference system, and Jest tests for the blotter's grouping and update logic. A pricing change that moved a golden price failed the build.

•Containerized services in Docker and deployed them to Kubernetes through Jenkins pipelines from Git, with a canary release before each full rollout. Rollbacks restored the previous image within the release window.

•Monitored pricing latency and failed requests in Grafana dashboards built on Prometheus metrics, alerting the support rotation before traders noticed stale prices.

•Cached the latest curves and reference data in Redis, so pricing requests stopped hitting Oracle for every bond.

•Partnered with traders and market risk managers to agree which risk measures the blotter showed and how they were bucketed. Desk and risk reports then showed the same DV01 by tenor.

•Reviewed Python and React pull requests from other developers, checking numerical tolerances, timezone handling, and error paths. Repeat findings went into a short coding standard for the desk's repositories.

•Mentored junior developers on QuantLib curve objects and pricing tests, pairing on their first pricing change. They later handled routine instrument additions on their own.

•Instrumented pricing exceptions in Splunk with the trade, curve snapshot, and request ID, so support traced a failed price without reproducing the desk's screen.

Tech Stack: Python, REST APIs, QuantLib, FastAPI, Pydantic, ReactJS, TypeScript, AG Grid, WebSockets, ArcticDB, pandas, MongoDB, Oracle Database, Apache Kafka, FIX Protocol, NumPy, Jupyter, statsmodels, pytest, Jest, Docker, Kubernetes, Jenkins, Git, Grafana, Prometheus, Redis, Splunk

ELEVANCE HEALTH - Dallas, TX Sep 2024 - Oct 2025

Senior Software Consultant

•Built Python analytics for the health plan's investment portfolio team, covering the corporate bond, municipal, and agency mortgage-backed holdings that back insurance reserves. Portfolio managers reviewed duration and credit exposure from one service instead of spreadsheets per manager.

•Developed Flask REST services that returned holdings, yields, and exposure by issuer and sector to the portfolio dashboard. Each response carried the pricing date so users knew how current the numbers were.

•Built the portfolio dashboard in ReactJS with Redux Toolkit, showing exposure by sector, rating, and maturity bucket. Managers drilled from a sector total to individual bonds without asking for a report.

•Modeled bond yields and effective duration with SciPy root-finding on cash flows from the security master. Results were checked against the custodian's analytics each month before managers relied on them.

•Loaded custodian holdings and transaction files with pandas, validating CUSIPs, par amounts, and settlement dates before they reached the database. Files with unknown securities were held for the operations team.

•Extracted end-of-day prices and reference data through Bloomberg BLPAPI for securities the custodian did not price. Missing prices were listed for the operations team before the dashboard refreshed.

•Diagnosed duration figures that jumped for callable municipal bonds, caused by yield-to-worst switching between call dates on small price moves. The analytics reported both yield-to-call and yield-to-maturity durations with the governing date shown.

•Resolved mortgage-backed holdings undercounted after a custodian file change, traced to factor updates arriving in a new column. The loader mapped the new column and the affected months were reloaded.

•Modeled holdings and analytics in PostgreSQL through SQLAlchemy models with one row per security and pricing date.

•Wrote pytest tests for yield and duration functions against hand-checked examples.

•Triaged data questions from portfolio managers and investment accountants, reproducing each against the stored holdings before changing code. Most traced to late custodian files, which went to operations with the file name.

•Partnered with investment accounting to match reported book yields with the accounting system, agreeing which amortization method each figure used. Month-end reviews stopped stalling on yield differences.

•Containerized the services in Docker and released them through GitHub Actions after tests passed.

•Documented the analytics definitions and data sources in Confluence for portfolio managers and accountants. New analysts answered definition questions from the document.

•Tracked enhancements and defects in Jira with the portfolio team's product owner.

•Tracked API request and data load results in Splunk for support.

Tech Stack: Python, Flask, ReactJS, Redux Toolkit, SciPy, pandas, Bloomberg BLPAPI, PostgreSQL, SQLAlchemy, pytest, Docker, GitHub Actions, Confluence, Jira

CITI BANK - Hyderabad, India Aug 2018 - Jul 2024

Software Consultant

•Developed Python pricing analytics for the bank's Markets rates and credit trading desks, covering government bonds, corporate bonds, and interest rate swaps for traders and desk strategists. The library priced positions for intraday risk screens and end-of-day reports.

•Maintained the desk's Excel-based bond pricing tools in the program's first year and rebuilt their core calculations as tested Python functions. Strategists kept their familiar sheets while the numbers came from the shared library.

•Migrated the desk analytics library from Python 2.7 to Python 3 before Python 2's end of life, running both versions side by side until prices matched across the trading book.

•Built bond pricing and risk functions with QuantLib and NumPy, including accrued interest, yield, DV01, and key-rate exposures. Results were reconciled with the official risk system before desks used them.

•Developed Flask REST endpoints that served pricing and risk to an internal ReactJS screen used by desk strategists. Strategists checked trade ideas against current risk without opening spreadsheets.

•Analyzed historical rates and spreads with pandas for desk strategists, building factor and carry analyses for relative-value ideas.

•Maintained pricing results and market data in Oracle Database, with SQL queries feeding the end-of-day reports.

•Built surveillance analytics for market misconduct with the compliance technology team, scoring wash-trade and marking-the-close patterns in trade data. Alerts reached compliance with the trades and prices behind each score.

•Traced a risk mismatch between the analytics library and the official risk system to different day-count conventions on a set of swaps. The convention was taken from the trade record, and the affected reports were rerun.

•Streamed trade events from Apache Kafka to keep intraday positions current between batch loads. Late or duplicate events were detected by sequence number and replayed.

•Wrote pytest suites for pricing and risk functions and ran them in Jenkins on every change. A change that moved a reference price failed the build.

•Versioned the analytics library in Git and released it as an internal package with change notes for each desk.

•Partnered with desk strategists and market risk to agree the inputs and conventions for each new instrument before build. Each instrument went live with signed-off test cases.

Tech Stack: Python, QuantLib, NumPy, Flask, ReactJS, pandas, Oracle Database, SQL, Apache Kafka, pytest, Jenkins, Git

MEDTRUST - Hyderabad, India Aug 2016 - Jul 2018

Software Consultant

•Developed Python features in a Django application for the hospital group's billing office, including charge review screens and payment posting reports, under the senior developer's review. Each change was tested on the staging server before release.

•Built JavaScript and early ReactJS components for the charge review screen, replacing a page that reloaded after every filter change. Billing staff filtered claims by payer without waiting for reloads.

•Wrote SQL queries and views in PostgreSQL for monthly revenue and denial reports. Report totals were matched to the billing system before release.

•Analyzed denial trends by payer and reason code with pandas for the revenue cycle manager.

•Scripted Python data validation for nightly charge imports, rejecting rows with missing payer or procedure codes before they loaded.

•Wrote unit tests with pytest for billing calculations before each release.

•Traced a payment posting report that double-counted partial payments to a join on the wrong key, and corrected the view. The affected months' reports were reissued.

•Built REST endpoints with Django for the payer lookup used by the billing screens. Lookups stopped hitting the payer table directly from the page.

•Versioned code in Git and followed the team's pull request review. Review comments were resolved before merge.

•Documented the billing report definitions for finance users. Questions on a number came back with the report name and filter.

•Handled first-line support for the billing application, escalating code issues to the senior developer. Tickets carried the screen and steps to reproduce.

Tech Stack: Python, Django, JavaScript, ReactJS, SQL, PostgreSQL, pandas, pytest, Git

EDUCATION

Master of Science - Data Science

University of North Texas

Contact this candidate