Kathmandu, Nepal • imbibek8366@gmail.com

I am an entry-level AI / Machine Learning Engineer with a software engineering background and a focus on building machine-learning systems from first principles through deployment.

My work spans PyTorch, Transformer architectures, tokenization, ML inference, data processing, LLM applications, FastAPI backends, and Docker-based deployment. I enjoy understanding how ML systems work underneath high-level abstractions and turning those implementations into usable software.

Status & Commitment: I am fully available for immediate full-time employment with zero academic commitments remaining. Having completed my degree and short-term project contracts, I am seeking a long-term role as an Associate/Junior ML Engineer where I can grow with a core engineering team and contribute to production systems over the coming years.

🎯 Recent: Completed AI/ML Internship at FlyRank AI (Published Capstone on Data Leakage & Search Intelligence)
🎓 Education: BCA final semester examinations completed in August 2026
💼 Status: Available immediately for full-time employment
🔎 Seeking: Associate / Junior ML Engineer, AI Engineer, or Entry-Level ML Engineer roles

• 🧠 Machine Learning & Deep Learning — PyTorch, TensorFlow, Scikit-Learn, Transformer architectures
• 🤖 LLMs & NLP — tokenization, BPE, RAG, AI agents, Hugging Face
• ⚡ ML Inference — ONNX Runtime, INT8 quantization, CPU inference, memory optimization
• 📊 Data Processing & Pipelines — DuckDB, BigQuery, PostgreSQL, SQLite, Pandas, NumPy, Pydantic, SQLAlchemy
• 🔧 Backend, MLOps & Deployment — FastAPI, Docker, Kubernetes, CI/CD, Automated Testing, REST APIs, PyPI Packaging
• 🌐 Applications — React, Next.js, Streamlit, Flutter

Enterprise Star-Schema Data Mart and Self-Serve BI Analytics Hub powered by DuckDB.

• Automated Data Pipeline: Engineered an automated ETL pipeline using Python and DuckDB to transform 100,000+ raw transactional records into a strict Kimball-methodology dimensional model.
• Synthetic Data Generation: Generated realistic synthetic business datasets (customers, products, channels, and orders) using the Python Faker library to simulate an enterprise data ecosystem.
• Advanced BI Integration: Built a comprehensive Power BI showcase dashboard utilizing explicit DAX and Time Intelligence measures (YTD, MoM Growth, Rolling Averages) for executive reporting.
• Enterprise CI/CD: Maintained strict engineering standards with automated Pytest coverage, Ruff linting, pre-commit hooks, and semantic versioning through Release Please via GitHub Actions.

End-to-End A/B Testing Analysis Framework with automated SRM safety checks and executive reporting.

• Statistical Rigor: Engineered a Python SDK that calculates required sample sizes pre-test using statsmodels to ensure well-powered experiments.
• Automated Safety Invariants: Enforced automated Sample Ratio Mismatch (SRM) anomaly detection via Chi-Square Goodness-of-Fit, halting evaluations if $p < 0.01$.
• Analytical Evaluation: Evaluated proportional metrics using Z-tests to compute exact p-values, relative lifts, and 95% Confidence Intervals.
• Executive Reporting: Programmatically generated 1-page HTML/PDF summary reports featuring data visualizations using Matplotlib, Seaborn, and Jinja2 templating.
• Enterprise CI/CD & Packaging: Packaged and published natively to PyPI, maintained with rigorous standards including Pytest coverage, Ruff linting, pre-commit hooks, and GitHub Actions (Release Please).

Automated Customer Cohort Retention and Lifetime Value (LTV) Analytics Engine.

• High-Performance Execution: In-process analytics using DuckDB to process 1,000,000+ transactional rows locally in ~174ms, massively exceeding the sub-5 second SLA constraint.
• Advanced SQL Transformations: Engineered complex data pipelines utilizing Window Functions, CTEs, and aggregated joins to accurately compute month-over-month retention and rolling LTV metrics.
• Automated Python ETL: Developed a fully automated pipeline scheduled via GitHub Actions that extracts raw data, performs heavy transformations, logs execution metadata, and exports BI-ready CSVs.
• Enterprise CI/CD: Maintained strict engineering standards with end-to-end Pytest coverage, Ruff linting/formatting, pre-commit hooks, and semantic versioning through Release Please.

Interactive Sales & Operations BI Dashboard built on automated Star-Schema Data Modeling.

• Automated ETL Pipeline: Designed to tackle scattered data sources by pushing heavy row-level transformations into programmatic Python/Pandas ETL steps, converting 50,000+ raw transactions into a strict dimensional Star Schema.
• Optimized Storage & BI Consumption: Exported normalized dimensional tables into a local SQLite database via SQLAlchemy and generated flat CSVs for highly-performant, cross-platform BI ingestion.
• Dynamic KPI Calculations: Developed a ready-to-use Power BI dashboard (.pbix) driven by dynamic DAX measures (Total Revenue, Profit Margins, YoY Growth, Rolling 30-Day Sales).
• Enterprise CI/CD: Maintained strict code quality via Ruff, Pytest, pre-commit hooks, and semantic versioning through Google's Release Please.

Decision-support ML system for SEO prioritization (FlyRank Capstone).

• Handled out-of-core data processing by querying and verifying a ~79 million row production warehouse directly from Hugging Face using DuckDB.
• Trained a Random Forest classifier on a curated 30,000-row anonymized dataset to identify pages underperforming their exact peer groups.
• Identified and documented a critical data leakage trap: a naive data split yielded an inflated 94% precision due to client overlap, which I corrected to an honest 64% using a strict client-grouped holdout split.
• Translated the model probabilities into a transparent, rule-backed "Action Playbook" to avoid black-box automated decision-making.
• Published the full methodology, leakage audit, and results as a deployed Research Paper.

SQL-driven exploratory analysis of e-commerce customer behavior, automated into an executive presentation.

• Automated Data Storytelling: Developed a Python CLI tool that runs the analytical pipeline end-to-end—from building a database to programmatically generating a 5-slide executive deck (.pptx & .pdf) complete with metric-backed insights and charts.
• SQL & DuckDB Analytics: Engineered 9 complex SQL queries and views using DuckDB to analyze RFM segments, cohort retention, profit concentration, and monthly churn trends.
• Synthetic Data Generation: Built a deterministic data generator using NumPy and Pandas to simulate realistic e-commerce transactions, customer archetypes, and category margins.
• Strict Engineering Standards: Maintained an enterprise-grade codebase governed by GitHub Actions, with robust test coverage via Pytest, strict linting/formatting via Ruff, and semantic versioning through Release Please.

Automated Multi-Source E-Commerce ETL Pipeline with Pandas Data Cleaning, Validation Checks, and SQL Storage.

• High Throughput ETL: Extracted, cleaned, validated, and loaded 100,000 messy records in ~2.24 seconds using in-memory pandas manipulation, outperforming the strict 30-second SLA by over 13x.
• Strict Validation & Quarantine: Leveraged Pydantic to assert strict data contracts (null constraints, typing), gracefully trapping and quarantining ~21% of corrupted records to flat files rather than failing silently.
• Data Standardization: Reconciled disparate payload sources (CSV/JSON), stripped invalid text artifacts, standardized dates, and imputed missing numeric logic prior to relational storage via SQLAlchemy into SQLite.
• Enterprise CI/CD Workflow: Established comprehensive repository standards via pre-commit hooks, Ruff for linting/formatting, Pytest for testing, and semantic versioning via Release Please.

DAG-orchestrated, parameterized, lineage-tracked ML pipeline with strict data quality gating.

• DAG Orchestration: Built an explicit Directed Acyclic Graph (DAG) using Prefect to isolate, monitor, and scale pipeline stages.
• Strict Quality Gating: Enforced declarative data boundaries with Pandera, natively halting execution before expensive training jobs if data is corrupt.
• Cryptographic Lineage: Integrated MLflow to cryptographically link every model artifact to the exact input data version (via SHA256 hash) and track hyperparameter metrics.
• Automated Promotion: Implemented CI/CD logic to evaluate newly trained models against the active production model, automatically assigning the @champion alias to the best performer.

Reproducible tabular ML pipeline enforcing justified feature engineering and cross-validated evaluation.

• Rejected "notebook-only" ML: designed the entire pipeline from data ingestion to feature engineering as pure, unit-tested Python functions.
• Enforced declarative feature justifications via a custom Python decorator registry, automatically halting the pipeline if rationale is missing.
• Implemented deterministic, saved train/val/test splits with strict data leakage checks to guarantee honest model evaluation.
• Evaluated a Logistic Regression baseline against a grid-searched Random Forest using 5-fold stratified cross-validation.
• Configured automated CI/CD gating using GitHub Actions, strictly enforcing >90% test coverage with Pytest, Ruff formatting, and semantic versioning via Release Please.

Production-ready, containerized machine learning inference API and native Python SDK with zero boilerplate.

• Dynamic Artifact Loading: Instantly serves .joblib or .pkl models by fetching them directly via HTTP URLs on startup using Environment Variables.
• Native Python SDK: Published on PyPI (pip install modelgate-py) to integrate dynamic loading and strict validation directly into existing codebases.
• Strict Input Validation: Uses dynamic schema.json boundaries to strictly validate incoming payloads, ensuring malformed data never hits the execution layer.
• Error Shielding Architecture: Overridden FastAPI exception handlers guarantee zero leaked Python stack traces, returning only clean 422 and 500 JSON responses.
• Containerized & CI/CD Enforced: Fully Docker-native, rigorously tested via Pytest (including interactive Jupyter notebooks), and governed by GitHub Actions (Ruff Linting, Release Please Versioning).

Horizontally scalable, latency-optimized machine learning model serving system built on Kubernetes.

• Inference Optimization: Leveraged ONNX Runtime and 8-bit Dynamic Quantization to significantly minimize the model's container memory footprint and CPU latency.
• Kubernetes Orchestration: Configured deployment topology with liveness and readiness probes to safely handle auto-scaling and pod lifecycle events.
• Zero-Downtime Rollouts: Integrated Locust load testing to explicitly verify that exactly 0 requests are dropped during live RollingUpdates under concurrent HTTP traffic.
• Standardized Engineering: Built as a robust FastAPI application, containerized via Docker, and tested strictly via Pytest within a modern Python ecosystem.

Enterprise-grade MLOps pipeline and real-time API for customer churn prediction and risk segmentation.

• Engineered a production-ready machine learning pipeline featuring experiment tracking and model registry via MLflow, alongside a real-time inference microservice built with FastAPI and containerized using Docker.
• Implemented strict declarative data contracts using Pandera (training data) and Pydantic (API payloads) to prevent silent data failures and ensure schema integrity.
• Secured model persistence using Skops instead of legacy pickle files to eliminate arbitrary code execution vulnerabilities in production environments.
• Evaluated multiple algorithm families using 5-fold Stratified Cross-Validation, ultimately selecting Logistic Regression (0.85 ROC-AUC) over Random Forest/LightGBM for superior probability ranking sensitivity on imbalanced datasets.
• Established a modern CI/CD workflow utilizing GitHub Actions, Pytest, Ruff for linting, and Google Release Please for automated changelog generation and semantic versioning.

Lightweight RAG agent designed for resource-constrained deployments.

• Implemented a custom ReAct-style Reason + Act loop using Google's Gemini API for tool selection and grounded responses.
• Built local retrieval using FAISS and used INT8 ONNX Runtime for lightweight CPU inference.
• Designed PDF processing around limited memory using page-by-page streaming and micro-batched indexing.
• Configured the inference runtime to reduce memory overhead in constrained environments.
• Implemented a GitHub Webhook-based update mechanism for updating indexed knowledge during deployment.

Byte-Pair Encoding tokenizer implemented from scratch and published as a Python package on PyPI.

• Implemented GPT-style regex pre-tokenization using Unicode-aware patterns for words, numbers, and punctuation.
• Built a frequency dictionary during BPE training to reduce unnecessary merge checks.
• Added memoization to avoid repeated tokenization work during inference.
• Implemented UTF-8 byte-level fallbacks to avoid out-of-vocabulary failures.
• Published the package to PyPI (pip install lexibyte): Lexibyte

A project exploring Transformer implementation, training, optimization, and lightweight inference.

• Implemented a GPT-2-style Transformer decoder using PyTorch primitives.
• Integrated the custom LexiByte BPE tokenizer.
• Experimented with FlashAttention and bfloat16 mixed precision for training.
• Built the architecture to understand Transformer components and training mechanics from the implementation level.

• Scaled the architecture to approximately 28M parameters.
• Trained the model on the TinyStories dataset.
• Used gradient accumulation to work within approximately 6 GB VRAM.
• Exported the model to ONNX and applied INT8 dynamic quantization for lightweight inference.
• Built a FastAPI + NumPy inference service.
• Containerized the application using Docker and tested it in low-memory deployment environments.

Phishing detection system combining structured URL features with linguistic signals.

• Combined structured URL features from ISCX with linguistic features from PhiUSIIL.
• Implemented a soft-voting fusion approach across the models.
• Used XGBoost with Platt scaling through CalibratedClassifierCV for probability calibration.
• Exposed the model through FastAPI.
• Built an interactive Streamlit interface for evaluation.
• Used Docker Compose to run the application components.

Neural-network engine implemented without a deep-learning framework, with real-time training visualization.

• Implemented dense layers, ReLU activation, and Softmax Cross-Entropy using NumPy matrix operations.
• Implemented the training pipeline to understand forward propagation, loss calculation, and backpropagation at a lower level.
• Added FastAPI WebSockets to stream training metrics.
• Built a React + HTML5 Canvas interface to visualize epoch, loss, and accuracy in real time.

A deep learning experiment demonstrating the diagnosis and correction of overfitting.

• Simulated a classic failure mode (memorizing noise) on a highly non-linear synthetic dataset using a deep Multi-Layer Perceptron (MLP) baseline.
• Diagnosed train/validation loss divergence and restored generalization by applying Dropout (p=0.5) and L2 Weight Decay in PyTorch.
• Built as a modular, reproducible Python package featuring deterministic data generation, agnostic training loops, and Matplotlib visualizations.
• Enforced robustness and code quality with Pytest, Ruff, pre-commit hooks, and GitHub Actions CI pipelines.

Reinforcement-learning agent trained with PPO.

• Trained an autonomous agent to safely navigate a lunar module to its landing pad using the Proximal Policy Optimization (PPO) algorithm.
• Standard RL benchmark environment, done as an extensive learning exercise.

AI / ML Engineering Intern — FlyRank AI | Jul 2026 – Sep 2026

• Engineered a CTR Opportunity Scoring model acting as a decision-support system to prioritize SEO metadata reviews.
• Used DuckDB to query and aggregate large-scale Parquet datasets (~79M rows) directly from Hugging Face, avoiding RAM bottlenecks, while training the final ML models on a 30k-row analytical slice.
• Conducted rigorous model evaluation, successfully identifying and mitigating client-overlap data leakage via strict grouped validation splits.
• Framed machine learning outputs as a human-in-the-loop action playbook, focusing on precision and real-world business constraints.
• Authored and deployed a comprehensive Research Paper detailing the validation methodology and error analysis.
• Completed various Anthropic Academy certifications for AI fluency and Claude API proficiency.

Data Science & ML Apprentice — Skill Shikshya | Apr 2026 – June 2026

• Completed a hands-on learning track covering machine-learning mathematics, vector computation, classical ML, and deep-learning concepts.
• Implemented ML concepts through practical exercises and projects.
• Built and served ML applications using FastAPI.
• Used Docker to containerize applications.
• Completed and defended the final project in July 2026.
• Completed Kaggle certifications for Pandas, Feature Engineering, Intro to ML, and Intermediate ML.
• Completed Skill Shikshya certifications for Data Science & ML Diploma.

Full-Stack Engineer Intern — Walkers Hive IT Professionals | Oct 2025 – Dec 2025 (Mandatory Academic Internship)

• Independently designed and implemented the architecture for the AcademiaOS MVP.
• Built backend services using FastAPI and Celery.
• Developed the frontend using Next.js.
• Implemented HTTP-only cookie authentication and role-based access control (RBAC).
• Used Docker as part of the application development and deployment setup.

Software Engineer — Nextwave Technology | Apr 2025 – Jul 2025 (Contract)

• Worked on new features, bug fixes, UI revamp, and the Google Play Store launch of the Academia mobile application.
• Maintained and fixed existing Flutter codebases.
• Migrated corporate websites to Next.js-based implementations.

Software Engineer — Walkers Hive IT Professionals | Nov 2024 – Apr 2025 (Contract)

• Built an e-commerce administration panel using React, MUI, and Redux-Saga.
• Developed Next.js frontends integrated with existing PHP backends.
• Worked across frontend development, application integration, and deployment.

Android Development Intern — CodSoft | Dec 2023 – Jan 2024 (Internship)

• Developed Flutter applications with Firebase Authentication.
• Implemented local persistence and BLoC state management.
• Worked on application UI and BAAS integration.

Nihareeka College of Management and Information Technology Tribhuvan University, Nepal • Completed Final Semester Coursework and Examination on August 2026

Status: Fully available with no remaining academic obligations.

• FlyRank AI — Machine Learning Internship Certificate Link
• Skill Shikshya — Data Science & ML Diploma Link

• Anthropic Academy — Claude Code in Action Link
• Anthropic Academy — Building with the Claude API Link
• Anthropic Academy — MCP Advanced Topics Link
• Anthropic Academy — Claude on Amazon Bedrock Link
• Anthropic Academy — Claude on Google Vertex AI Link

• Kaggle — Pandas
• Kaggle — Feature Engineering
• Kaggle — Intro to Machine Learning
• Kaggle — Intermediate Machine Learning

• Deployed ML Research Paper: CTR Opportunity Score Read Here A public research paper detailing my methodology on evaluating ML models honestly, mitigating data leakage, and framing ML as a decision-support tool.
• LunarLander-v2 Agent Link Trained an autonomous agent to safely navigate a lunar module to its landing pad using the Proximal Policy Optimization (PPO) algorithm.

• Email: imbibek8366@gmail.com
• LinkedIn: linkedin.com/in/bibek-dhakal-771ba5334
• Portfolio: Portfolio