Data Science

1. Cricket

As the author of the Cricket project in my Data-Science repository, I built a Python-based analytics toolkit that turns raw match data into actionable insights. The pipeline begins by loading CSV files into Pandas DataFrames and performing thorough cleaning and transformation—normalizing team names, handling missing values, and parsing date fields. From there, I extract and compute key metrics such as season-wise match counts, win margins by runs or wickets, overall team win tallies, and “Player of the Match” award frequencies. To make these insights accessible, I wrapped the analysis in a simple Tkinter GUI that presents menu-driven options for each metric, and I use Matplotlib to generate clear visualizations—bar charts for team comparisons, line plots for trend analysis, and histograms to show distribution of outcomes. This project not only demonstrates end-to-end data science best practices (from data ingestion through visualization) but also provides a user-friendly interface for non-technical stakeholders to explore cricket statistics with minimal effort.

2. ImageProcessing Project

As the author of this project, I developed a comprehensive workflow for leaf species detection and classification that combines advanced image‐processing with machine learning. I began by acquiring raw leaf images and enhancing their quality through histogram equalization, green‐pixel thresholding, and isotropic diffusion to remove noise. After segmenting each leaf from its background, I extracted a rich set of descriptors—shape, morphological, color histogram, and texture features—then calculated feature ratios to capture each species’ unique characteristics. For classification, I designed a two‐stage convolutional neural network (CNN) pipeline: first matching input features against a database via Euclidean distance, then refining predictions using color histogram correlation. This dual‐stage approach consistently delivered over 90% accuracy, even as the dataset grew in complexity. The implementation leverages OpenCV, Matplotlib, Mahotas, and PIL for efficient processing, and the modular structure supports future enhancements like transfer learning and attention‐based models to further improve performance.

3. LokSabha

As the author of the LokSabha project, I built a Python-based analytical framework to explore India’s parliamentary election data at the constituency level. I began by ingesting raw CSV files—covering vote counts, turnout percentages, and candidate details—into Pandas DataFrames, then applied rigorous cleaning steps to handle missing values, normalize party names, and merge datasets across multiple election years. Leveraging exploratory data analysis and visualization libraries such as Matplotlib and Seaborn, I produced interactive charts that reveal trends in voter engagement, party performance, and margin-of-victory across states and constituencies. To deepen insights, I implemented clustering algorithms to group constituencies by voting behavior and used regression models to assess the impact of demographic factors on election outcomes. All code is modularized into reusable notebooks and scripts, with clear documentation and plotting functions that allow other researchers to replicate and extend the analysis for future elections.

4. Best Card

As the author of this project, I designed and executed an end-to-end machine learning pipeline to predict EMI defaulters using the BestCard dataset. I began by ingesting raw transaction and customer data—encompassing demographics, credit‐history metrics, and payment behaviors—and performed comprehensive data cleaning and feature engineering to surface the most predictive variables. Leveraging exploratory data analysis, I identified key patterns in credit utilization and delinquency, then trained and fine‐tuned a suite of models, including logistic regression, random forests, and XGBoost, to maximize predictive accuracy. To streamline reproducibility and collaboration, I automated the preprocessing and model‐training steps within a modular Jupyter notebook framework and integrated them into an MLOps workflow for continuous evaluation and deployment. The resulting solution achieved strong performance in identifying high-risk cardholders, enabling targeted interventions that translate to significant loss savings for financial institutions.

5. MangaWork

As the author of the MangaWork project, I built a modular Python pipeline to collect, preprocess, and analyze manga artwork and metadata. I began by implementing web-scraping routines using Requests and BeautifulSoup to download high-resolution page images and associated metadata from public sources. Next, I applied image-processing techniques with PIL and OpenCV—such as grayscale conversion, adaptive thresholding, and panel segmentation—to normalize artworks and isolate individual comic panels. I then extracted quantitative features (color histograms, edge density, texture metrics) and stored both images and metadata in a lightweight SQLite database for efficient querying. For exploratory analysis, I leveraged Pandas alongside Matplotlib and Seaborn to visualize distributions of art styles, composition patterns, and genre trends. Finally, I developed and trained convolutional neural network classifiers in TensorFlow to automatically categorize manga pages by genre and artist style, achieving strong accuracy on held-out test sets. The entire project is organized into clear, reusable scripts and Jupyter notebooks, providing a solid foundation for future extensions such as real-time dashboards or deeper visual-language modeling

6. TempeGov

As the author of the TempeGov project, I built a Python-based analytics pipeline that ingests diverse open-data feeds—ranging from service-request logs and infrastructure inspections to community event schedules—and transforms them into actionable insights for city planners and residents. After retrieving data via API calls and CSV imports, I used Pandas to clean, normalize, and merge records across neighborhoods and timeframes, then applied time-series analysis to uncover seasonal trends in service demands (e.g., pothole repairs, streetlight outages). To visualize spatial patterns, I integrated Folium and Plotly to generate interactive maps and dashboards that highlight high-priority maintenance zones and track response times. Clustering algorithms helped identify “hotspot” regions where resource allocation could be optimized, while automated reports deliver weekly summaries of key performance indicators to stakeholders. The modular, well-documented codebase ensures that new data sources—such as traffic sensor feeds or public safety records—can be added seamlessly, making TempeGov a scalable tool for driving data-informed decision-making in municipal operations.

7. University Preferences

As the author of the Universities Preferences project, I built a complete Python-based analytics pipeline to uncover what drives students’ university choices. I began by ingesting multiple CSV files—student survey responses on criteria like academic reputation, location, cost, campus life and program offerings—then enriched them by merging with external university ranking and demographic datasets using Pandas. After rigorous data cleaning and feature engineering, I conducted exploratory analyses and correlation studies to quantify the impact of each factor on decision-making. To make these findings actionable, I developed interactive Matplotlib and Seaborn dashboards that allow stakeholders to filter by region, major and budget, reducing analysis time by over 60%. Next, I applied K-means clustering to segment students into distinct preference profiles and prototyped a recommendation engine that matches individual profiles with universities based on weighted preference scores. The modular, well-documented codebase facilitates easy extension—whether adding sentiment analysis on campus reviews or integrating web-based visualizations—so that this framework can evolve alongside future data and stakeholder needs.

8. WAT

As the author of this project, I developed a comprehensive, end-to-end data science workflow in Python and Jupyter Notebooks to evaluate student performance across multiple classrooms. I ingested and merged five CSV datasets—covering raw essays, essay scores, metric definitions, metric categories, and classroom rosters—then cleaned and transformed the data using Pandas to ensure consistency and reliability. Leveraging exploratory analysis, I examined how students performed across essay categories such as grammar, creativity, and structure, and visualized classroom-level distributions to identify outliers and trends. To track progress over time, I crafted time-series plots that highlight key turning points in individual student development, enabling educators to assess the impact of instructional interventions. Throughout, I used Matplotlib and Seaborn to produce clear, interactive dashboards that reduced analysis time and surfaced actionable insights for tailoring teaching strategies and measuring engagement. All code, data, and visualizations are available in my GitHub repository for replication and further exploration.

Cloud Architectures

1. IaC

As the author of the TerraformNew project, I built an end-to-end, infrastructure-as-code solution to provision and manage a complete AWS environment using Terraform. The codebase is organized into discrete modules—networking (VPCs, public and private subnets, route tables, Internet and NAT gateways), security (security groups, IAM roles and policies), compute (EC2 instances, Lambda functions), data stores (RDS MySQL with credentials fetched from AWS Secrets Manager, DynamoDB tables), and integration services (API Gateway, SNS topics, S3 buckets). I configured a remote state backend in S3 with DynamoDB locking to ensure safe, concurrent workflows, and parameterized everything via `variables.tf` so that separate workspaces (dev, staging, prod) can be spun up with minimal changes.

To streamline credential management, I wrote Terraform logic that automatically retrieves database credentials from Secrets Manager and injects them into RDS and Lambda environment variables, eliminating hard-coded secrets and enforcing least-privilege access. Networking is hardened by modular security groups and private subnets for databases and Lambdas, while public endpoints are tightly controlled. All resources are tagged consistently for cost-tracking and compliance.

Beyond provisioning, I embedded best practices throughout: clear outputs for newly created ARNs and endpoints, thorough documentation in README.md, and a CI/CD-ready structure that can be invoked from Jenkins or GitHub Actions. By abstracting common patterns into reusable modules, this project not only delivers repeatable, secure environments in minutes but also serves as a reference architecture for scalable, production-grade Terraform deployments in AWS.

2. AWS Services

As the author of the MyPastWork repository, I assembled a comprehensive collection of AWS infrastructure-as-code examples and operational playbooks to demonstrate best practices in cloud architecture and management. The repository is organized into service-focused modules—networking constructs with VPCs, subnets, routing and gateways; compute patterns deploying EC2 instances in single-zone, multi-AZ and load-balanced configurations; managed databases using RDS and DynamoDB; scalable object storage with S3; serverless and PaaS workflows through Elastic Beanstalk; global content delivery via CloudFront; and container orchestration on EKS—each template designed for consistency, least-privilege security, and flexible parameterization to support dev, staging, and production environments.

Advanced Terraform concepts are showcased in dedicated folders that illustrate dynamic block generation, creation of reusable modules, and remote state backends backed by S3 with DynamoDB locking for safe concurrency. Supplemental directories cover operational scenarios—state file recovery, multi-account deployments, and resource importation—while CI/CD integration examples demonstrate how these templates can be seamlessly incorporated into automated pipelines.

Altogether, this repository serves as a production-grade reference architecture, streamlining the entire lifecycle of AWS resources from initial provisioning through ongoing maintenance, with built-in guidelines for security, cost optimization, and automated delivery.

3. DockerFile

As the author of this project, I curated a hands-on collection of Docker examples that demonstrate containerizing a variety of technology stacks. The repository is organized into five focused Dockerfiles—each in its own folder—showcasing best practices in image design and build optimization:

Ubuntu Base Image: A minimal, secure Ubuntu container that installs core system utilities, applies security updates, and establishes a clean foundation for downstream images.

Java Runtime & App: A Java container that installs the JDK, sets working directories, and deploys JAR artifacts with a streamlined ENTRYPOINT, illustrating how to package and run Java applications in Docker.

Maven Build Environment: A Maven builder image that layers in Maven and its dependencies, enabling reproducible, cache-friendly builds of Java projects before handing off artifacts to a runtime image.

Nginx Web Server: An Nginx container preconfigured with custom server blocks and optimized for static-file delivery or reverse-proxy duties, complete with volume mounts for easy configuration swaps.

OpenAI SDK & Python: A Python-based image that installs the OpenAI client library and its prerequisites, providing a ready-to-use environment for developing or serving AI-powered applications.

Across all examples, I employed multi-stage builds to minimize final image sizes, leveraged build cache for efficient rebuilds, and parameterized configurations via environment variables—offering a clear, reproducible guide to containerizing everything from traditional web servers to modern AI toolkits.

Business Intelligence