Set up the data product platform for Intuit to allow access to data all across Intuit. Data products aim to reduce the time to access data, enable exploration, and track the usage of data through its lineage.

Set up the authorization model for data product service. Migrated the existing Role Based Access Control (RBAC) authorization model to an Attribute base Access Control (ABAC) one. Set up various Policy-Enforcement-Points (PEPs), Policy-Decision-Points(PDPs), and Policy-Information-Points(PIPs) to enable the various authorization use cases for data product service.

Enabled the securing of the entire Intuit data lake consisting of over 180,000 hive tables by implementing the ability to request access to data products by identifying the data stewards of a particular data product and messaging them via a Slack bot integration to grant access to the underlying hive tables and Kafka topics.

Furthered the securing of the data lake by providing automatic access to over 90,000 hive tables which contained no sensitive data and required no manual access requests from the data stewards so that the exploration and access time for data can be lowered significantly.

Leading the setup of the ADAS cloud.

Designing and implementing scalable architectures for enabling various ADAS use cases.

First author for ADAS cloud platform code repo.

Setup over 10 different microservices to handle the myriad of cloud use cases. Each

service is fully replicable and stateless. Most of the services are primarily written in Golang. Codebase strictly follows SOLID design principles. Wrote the Kubernetes manifests for the various deployments, services and ingress for the microservices as well.

Setup a Distributed Load Test framework to stress test the microservices to the absolute limit and generate performance metrics.

Applied learnings from CAP theorem to tailor the system accordingly for the different use cases.

Setup a pipe to receive HD Map patches on a scheduled basis from a 3rd party. Moreover, I designed the system to deliver the patches down to the entire vehicle fleet in an asynchronous and synchronous manner. This involved setting up gRPC streaming API’s and integrating with the existing over-the-air (OTA) update system to send patches down periodically with monthly updates.

Handled all the security related to vehicle-to-cloud communication. This involved carefully designing proper authentication via JWTs, TLS certificates and VPN networks.

Setup microservices to integrate with Amazon Athena and Databricks to query petabytes of data. This data was then returned to the user via APIs.

Setup the entire Docker-based make/build system for the codebase, utilizing techniques such as Multi-stage Docker builds and building agnostic of the local operating system. Aided the setup of the CI/CD as well on Bitbucket.

Wrote unit tests for all the microservices and made it a part of the multi-stage docker build/make process. Pushed code coverage to over 90%.

Setup a grpc-rest gateway for the services to allow the clients to query via both REST and gRPC protocol on the same port.

Setup an entire microservice-based architecture for the vehicle control network. This involved setting up various components like MQTT broker, Kafka Broker, Mongo DB, Kubernetes, Docker, and various microservices.

The system is scalable on all axes of scaling (x,y,z) and is fault-tolerant. Moreover, the system guarantees message delivery throughout with a Quality of Service assurance of either 1 (at least one message) or 2 (exactly one message delivery) for some high priority signal.

Once the connected car functionality was developed, I integrated with the mobile app team and the telematics control unit team to enable cloud-based vehicle control. Functionalities such as Locking/Unlocking of the vehicle from the mobile app and Flashing lights and honking the horn.

Moreover, functionalities such as preconditioning the vehicle temperature from the mobile application and seeing the response back on the phone in real-time are developed. Fully bi-directional communication between car and cloud is developed with quality of service of 1 or better.

Kickstarted the Alpha In-vehicle logger to be able to upload data to the cloud and set up the cloud services to receive that data and put them in Amazon S3 through Kinesis streams.

Evaluated an Over the air update system so as to be able to perform updates on the vehicle software.

Developed a file chunker to be able to chunk a file based on some predefined chunks and then re asseble them.

Setup a scalable cloud platform for Cohesity's Multi-Cluster Management software called Helios. This involved dockerizing the existing services and then deploying them on the Kubernetes Cloud.

Reading and aggregating data from the elastic search containers and displaying a conglomerated dashboard. Moreover writing the connectors for the elastic search DB container from the dashboard application container.

Augmented the existing system of a username and password-based authentication to integrate with a second-factor auth system. This involved integrating with Active Directory and getting the certificates tied to the user (Public Key) and then reading the certificate from the applications OS Keystore (Public-Private key pair) and then performing the successful TLS handshake. Thus logging in the user.

Developed a scheduler to send configurable reports on a schedule to a list of senders using channels in Golang.

Worked on the Gateway team to set up API's for interfacing the various components.

Wrote connectors for the in house Database (Scribe) to enable connection to the application layer in C++.

Developing a dashboard which visualizes NVH (Noise, Vibration and Harshness) data using D3.js.

Setting up the LEMP stack for the deployment of the NVH Dashboard and analysis platform

Developing REST services utilizing python, Flask and gunicorn which will be used to get the data for the front end from Mongo database.

Applying supervised and unsupervised learning techniques using the vehicle data to identify potential sources of noise in the car and classify cars on the basis of build quality.

Formulating the queries to optimize access to Mongo database.

Increasing efficiency of read and write to database by applying techniques like sharding and replication