Backend-leaning Software Engineer

Hi, I'm Anshul.

CS Senior at ASU that loves bringing automation to backend systems

From rule-based URL retrieval systems that reduced false-negative cases by 98%, to automated Python scripts that brought down utility rate turnaround time from 3 hours to 75 mins, my experiences have guided me to build reliable, reusable software that saves time and manual work into dependable infrastructure.

I am also pursuing a minor in Data Science. Reason? Since the time I was introduced to Python and MySQL in high school to analyze World Heritage Sites in India, I've been drawn to presenting, analyzing, and visualizing data. That interest has grown into projects like ML Rain Predictor and Violence analysis in Sudan, and it continues to shape how I turn technical findings into insights that make sense to broader audiences.

Scroll to explore experience, projects, and campus life

At a glance

A quick snapshot of where I am right now.

Graduation May 2026

GPA 4.00 / 4.00

Focus Backend, ETL, scalable systems

Current role Backend SWE Intern
Qualaces Inc / JobQue.AI

Previous role Database Engineering Intern
NREL (US Dept. of Energy)

Experience

A mix of production backend work, energy data systems, operations, and service-focused problem solving.

Latest Experience

Backend Software Engineering Intern

Qualaces Inc / JobQue.AI • Remote, AZ

Company website link

active

Aug 2025 - Present

current role

98% Failed retrievals cut

53% Pipeline speedup

95% Merge conflict reduction

Career URL Automation

Built a Python automation system to retrieve career-page URLs from job-posting links using rule-based parsing and ATS normalization across platforms like Workday and Lever.

Payments Infrastructure

Designed a production payment system with Stripe APIs, webhook validation, idempotent event handling, and retry logic for fully reliable referral and promo-code flows.

Extraction Pipeline

Optimized the extraction pipeline with multithreaded processing, caching, and retries to improve throughput and keep backend workflows resilient under load.

Cloud Workflows

Built backend workflows on AWS Lambda and DynamoDB and supported CI/CD via GitHub Actions to keep production changes cleaner and easier to ship.

url_extraction.py

# Workday
if "myworkdayjobs.com" in domain:
    parts = path.strip('/').split('/')
    if len(parts) >= 1:
        new_path = ""
        for part in parts:
            if part.lower() in ['job', 'details', 'user']:
                break
            new_path += "/" + part
        return f"{parsed.scheme}://{domain}{new_path}", "Workday Pattern"

# Lever
if "jobs.lever.co" in domain:
    parts = path.strip('/').split('/')
    if len(parts) >= 1:
        return f"{parsed.scheme}://{domain}/{parts[0]}", "Lever Pattern"

# Greenhouse
if "boards.greenhouse.io" in domain:
    parts = path.strip('/').split('/')
    if len(parts) >= 1:
        return f"{parsed.scheme}://{domain}/{parts[0]}", "Greenhouse Pattern"

# iCIMS
if "icims.com" in domain:
    return f"{parsed.scheme}://{domain}/jobs/intro", "iCIMS Pattern"

Previous Experience

Database Engineering Intern

NREL (US Dept. of Energy) • Remote, CO

Open Source Code Link for ELM

completed

Jan 2025 - Dec 2025

12 months

3,000+ Electric data sources

20,000+ Records processed

75 min Manual work saved

Energy LLM Backend

Designed a Python backend integrating LLM workflows into an Energy Language Model supporting thousands of electric data sources and domain-specific queries.

ETL Runtime

Built scalable ETL pipelines with PyTorch, DuckDB, Rust, and Pandas, including real-time REST API ingestion for large-volume utility data.

Rule-Based Automation

Wrote rule-based Python scripts that automated repeated utility computations at scale and significantly reduced per-utility manual analysis time.

Systems Debugging

Debugged distributed backend services in Linux using GDB, logging, indexing, and low-level investigation to resolve reliability issues across the stack.

cleveland_script.py

# script for cleveland utility - hashMaps for each adjustment rider and main calculation function
# Total Adjustment Surcharge Rider
TAS = {
    "RS": "-0.001908e",
    "GS": "-0.4908d",
    "GP": "-0.3554d",
}

# calculates all three kinds of adjustments
def calculate(rate):
    eList, dList, mList = [], [], []
    e, d, m = 0, 0, 0
    for rider_name, rider_dict in all_riders.items():
        if rate in rider_dict:
            val = rider_dict[rate]
            valInt = float(val[:-1])
            if val.endswith('e'):
                eList.append(rider_name)
                e += valInt
            elif val.endswith('d'):
                dList.append(rider_name)
                d += valInt
            elif val.endswith('m'):
                mList.append(rider_name)
                m += valInt
    return [round(e, 5), round(d, 5), round(m, 5)]

Operations

Program Operations Intern

EECPLL, W.P. Carey School of Business • Tempe, AZ

Department Link

completed

Jul 2024 - Dec 2024

6 months

45 min Saved per course

400 Learners analyzed

3 Enterprise partners

Report Automation

Automated grade calculations for employee learners using VBA and Excel scripts, cutting repetitive reporting work and speeding up course operations.

Stakeholder Operations

Supported cross-functional program work tied to Starbucks, AmEx, and Mayo Clinic while surfacing HubSpot KPI reporting for leadership review.

Dashboarding

Built Tableau dashboards aggregating Canvas LMS engagement data to help the team make faster, more informed decisions across learner cohorts.

google_sheets_script.js

function onEdit(e) {
  var sheet = e.range.getSheet();
  
  // Check if the edited cell is D21 (thisWeek)
  if (e.range.getA1Notation() === "D21") {
    var thisWeekCell = sheet.getRange("D21");
    var lastWeekCell = sheet.getRange("E21");
    var totalCell = sheet.getRange("G21");

    var thisWeek = thisWeekCell.getValue();
    var currentTotal = totalCell.getValue();

    if (currentTotal === "") {
      totalCell.setValue(thisWeek);
      lastWeekCell.setValue(0);
    } else {
      lastWeekCell.setValue(currentTotal);
      totalCell.setValue(currentTotal + thisWeek);
    }
  }
}

Volunteer Work

Oxygen Data Volunteer

CoviO2 Foundation • Remote, India

completed

Jul 2021 - Sep 2021

3 months

5 Metro cities

150/day People supported

COVID Emergency response

Supply Chain Data

Designed MySQL databases for oxygen supply chain data across major metro areas to make rapidly changing healthcare information searchable and structured.

Indexed Access

Standardized and indexed provider data so people could connect with nearby oxygen resources faster during a high-pressure public health crisis.

Projects

A few representative builds across full-stack product work, systems, and data analysis.

Featured Project

SunDevil EBAY

eCommerce Platform

Website link GitHub link (private repo)

Why I built this? Noticed a market gap: hundreds of students move in and out of apartments on campus, and there is always demand for household items, tech gadgets, scooters, and other essentials to be sold, rented, or bought through something accessible and genuine.

Server-First Architecture

Built with Next.js and TypeScript using a server-first approach that reduced client-side JavaScript by roughly 30%.

Database Design

Designed a relational PostgreSQL schema to manage users, listings, inventory, and transaction flows.

Role-Based Dashboards

Built separate experiences for Admin, Buyer, and Seller workflows with analytics and responsive layouts.

Deployment

Deployed the product on Vercel and structured the application around marketplace usability and clean operational flows.

seller_selection.js

# list all users when a seller wants to select with whom the deal was closed
const { PrismaClient } = require('@prisma/client')
const prisma = new PrismaClient()

async function main() {
    const users = await prisma.user.findMany()
    console.log('Total users:', users.length)
    console.dir(users, { depth: null })
}

main()
    .catch(e => {
        console.error(e)
        process.exit(1)
    })
    .finally(async () => {
        await prisma.$disconnect()
    })

# frontend for 'Get Seller Details' button
import { useState } from 'react'
import { signIn, useSession } from 'next-auth/react'
import { useRouter } from 'next/navigation'

export default function SellerDetailsButton({ productId, sellerEmail }) {
    const { data: session } = useSession()
    const [showDetails, setShowDetails] = useState(false)
    const [loading, setLoading] = useState(false)
    const [sellerDetails, setSellerDetails] = useState(null)
    const router = useRouter()
}

Systems Project

Operating System Kernel

Kernel and Runtime Systems

GitHub link

What does this project do? As part of my Operating Systems class, this final project, in non-technical terms, is a user program (guest) asking for memory space (hotel room) and interacting with the kernel ioctl (hotel manager) to make that request happen.

Execution Model

Built support for ELF execution, syscalls, and user-space programs inside a custom kernel environment.

Memory System

Implemented paging, virtual memory allocation, and multi-level page tables for kernel and user memory control.

Concurrency

Added locks, mutexes, and semaphores to support multithreaded kernel behavior.

Scheduling

Implemented a Round-Robin scheduler with multicore-aware execution across kernel tasks.

memalloc_ioctl.c

/* IOCTL handler for vmod. */
static long memalloc_ioctl(struct file *f, unsigned int cmd, unsigned long arg) {
    switch (cmd)
    {
    case ALLOCATE:  // Handle allocation requests from user space.

        // Copy the allocation request into kernel space safely.
        if (copy_from_user(&alloc_req, (void*)arg, sizeof(struct alloc_info))) {
            printk("Error: Failed to copy alloc_info from user.\n");
            return -EFAULT;
        }
        printk("IOCTL: alloc(%lx, %d, %d)\n", alloc_req.vaddr, alloc_req.num_pages, alloc_req.write);

        // Reject requests that would exceed the allowed page limit.
        if (total_pages_allocated + alloc_req.num_pages > MAX_PAGES) {
            printk("MAX Limit of pages: too many pages allocated (%d)\n", total_pages_allocated);
            return -2;
        }

Machine Learning Project

Rainfall Predictor ML Model

End-to-End Weather Modeling Pipeline

GitHub link

Why this project matters? This final project for my Machine Learning class is something I coded from scratch. It builds an end-to-end machine learning pipeline to predict daily rainfall using historical Arizona weather data, and it taught me the full machine-learning lifecycle from messy real-world data to evaluated models and responsible deployment thinking.

Data Preparation

Cleaned and aggregated 25+ years of weather data, then engineered domain-driven features such as temporal signals, pressure changes, and lag variables.

Model Prototyping

Built and benchmarked multiple regression models including baseline, multi-feature, and forward-selected variants to study performance and complexity tradeoffs.

Evaluation

Used cross-validation with R², RMSE, and MAE to compare model quality and generalization behavior.

Deployment Thinking

Analyzed overfitting, feature redundancy, and bias, then documented model limitations and scalability considerations for real-world deployment.

rainfall_model.py

# feature engineering
# calling the dataframe as DF for simplicity
DF = df_2_daily
DF = DF.dropna() # we can't do regression with NaN values

# multi-regression model
def model_results(name, model, X_train, X_test, y_train, y_test, feature_names):
    """
    Train model and display comprehensive results
    Adapted from MLR_Demo.ipynb
    """
    # Fit model
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    # Standardized coefficients β* = β_j * (σ_xj / σ_y)
    if isinstance(X_train, pd.DataFrame):
        sx = X_train.std(axis=0, ddof=0).values
    else:
        sx = X_train.std(axis=0, ddof=0)
    sy = np.std(y_train, ddof=0)
    std_coefs = {f: b * (sx[i] / sy) for i, (f, b) in enumerate(zip(feature_names, model.coef_))}

# model evaluation using residual approach

Data Science Project

Political Violence in Sudan

Data Analysis and Modeling

GitHub link

Why this project matters? This project is special to me because I got to invest more deeply in my Data Science area of interest by building a multi-source analysis of political violence in Sudan. Again coding the entire lifecycle from scratch, this project focused on data cleaning, modeling, geospatial interpretation, and making complex findings easier to communicate.

Data Wrangling

Built a repeatable cleaning workflow across 5+ datasets from UNHRC, HDX, and government sources using imputation, outlier removal, and reproducible preprocessing across multiple datasets.

Statistical Modeling

Applied regression models and exploratory analysis to surface trends in political violence indicators across regions and timelines.

Geocoding

Used spatial workflows and geocoding to support geographic interpretation and map-based outputs.

Communication

Combined analysis with interactive dashboards and visual storytelling to make the findings easier to explain.

sudan_analysis.R

# Summarizing the civilian targeting data
civilian_summary <- civilian_targeting_data %>%
  summarise(total_events = sum(Events)) %>%
  mutate(violence_type = "Civilian Targeting")

# Summarizing the political violence data
political_summary <- political_violence_data %>%
  summarise(total_events = sum(Events), total_fatalities = sum(Fatalities)) %>%
  mutate(violence_type = "Political Violence")

# Identifying major conflict hotspots using OSM geocoding
# Example: Geocoding the demonstration data using Admin1 (regions)
# Summarize the data by region to reduce the number of requests
demo_hotspot <- demonstration_data %>%
  group_by(Admin1) %>%
  summarise(total_events = sum(Events)) %>%
  filter(total_events > 0)  # Only include regions with events

# Geocode the Admin1 regions to get latitude and longitude
geo_data <- demo_hotspot %>%
  geocode(Admin1, method = 'osm', lat = Latitude, long = Longitude)
# head(geo_data)

Skills

A practical stack shaped by backend engineering, systems courses, cloud workflows, and applied data work.

Core Toolkit

Backend-first, data-aware, and comfortable across product to infrastructure.

The tools I reach for most often sit at the intersection of backend systems, data workflows, cloud automation, and applied ML.

Primary Language Python for automation, ETL, and ML pipelines

Frontend + Product Next.js, TypeScript, React, and Vercel

Cloud + Infra AWS Lambda, DynamoDB, Docker, CI/CD

Data + Modeling PyTorch, scikit-learn, DuckDB, Pandas

Languages

Python (Advanced) TypeScript C C++ Java JavaScript SQL Linux

Frameworks & Libraries

Next.js React Node.js PyTorch Scikit-learn Pandas Polars (Rust) Matplotlib Seaborn Streamlit

Databases

PostgreSQL MySQL SQLite DuckDB MongoDB DynamoDB

Tools & Platforms

Git GitHub Jira Vercel OpenAI APIs AWS (Lambda, DynamoDB) Docker CI/CD

Education

Academic Profile

Arizona State University

Tempe, AZ

Bachelor of Science in Computer Science
Minor in Data Science

A strong academic foundation built around data structures, algorithms, logic, machine learning, AI, and the core theory behind reliable, scalable software.

Graduation May 2026

GPA 4.00 / 4.00

Honors & Awards

Academic recognition

Dean's List Award 2022 - 2026

New American Scholar Recipient 2022 - 2026

Relevant Coursework

Core academic focus

Machine Learning Foundations of AI Operating Systems Data Structures & Algorithms Cybersecurity Computer Networks

Campus Life

Outside of engineering, I've spent my college years teaching, tutoring, leading, and serving the ASU community.

Student Support

Dec 2023 – Dec 2024

Academic Tutor

Academic Support Network · Tempe, AZ

Tutored 200+ students monthly across 26 courses, from Discrete Math to C++ and Python.
Provided additional ASAP tutoring to freshmen in foundational math and science.

Teaching

Jan 2023 – Aug 2024

CSE Teaching Assistant & Grader

Ira A. Fulton School of Engineering · Tempe, AZ

Facilitated lectures and discussions for 110 students in CSE 100 & 110 (C++ & Java).
Led weekly office hours and comprehensive exam reviews.

Operations

Feb 2023 – Dec 2023

Aramark Student Store Worker

Tooker POD House · Tempe, AZ

Served 850 patrons daily with accurate handling of inventory, payments, and inquiries.
Managed administrative tasks including data entry, deliveries, and office equipment.

Leadership

Aug 2021 – Jan 2022

Secretary General

CENMUN, Centre Point School · Nagpur, India

Led two online Model UN conferences for 700 delegates with a 34-person executive board.
Managed logistics, registrations, recruitment, budgeting, and guest coordination.

Athletics

2024 – 2026

Semi-professional Cricketer

ASU National College Team

Part of the ASU Collegiate team, representing the college at regional and national college tournaments.
Won the West Zone regional championship 3 times in 2 years.

Get in Touch

I'm always open to new opportunities, collaborations, or just a good conversation!

akamble7@asu.edu LinkedIn GitHub 602-471-9923