M. ENGINEERING SYSTEMS
PORTFOLIO / 2026
INITIALIZING 00%
M.
A LITTLE SPACE TO BUILD BIG THINGS

WELCOME.

TO MOMNA'S ENGINEERING WORLD

CLOUD✳ DEVOPS✳ AUTOMATION✳ RELIABILITY✳ KUBERNETES✳ CLOUD✳ DEVOPS✳ AUTOMATION✳ RELIABILITY✳ KUBERNETES✳
SYSTEMS WITH PURPOSE
01 — 06
CASE STUDY 05 / NETWORK SECURITY & MLOPS
END-TO-END MLOPS

From data
to detection.

Network Security System using End-to-End MLOps

Connecting URL-feature data, machine-learning model training, FastAPI prediction serving and automated cloud deployment through a containerized MLOps workflow.

PYTHON SCIKIT-LEARN FASTAPI MLFLOW DOCKER GITHUB ACTIONS AWS
END-TO-END MLOPS WORKFLOW 01 — 05
01
MongoDB Atlas Data ingestion
↘
02
Data Pipeline Validation & transformation
↘
03
ML Training Model selection & MLflow tracking
↘
04
FastAPI + Docker Prediction service & container image
↘
05
Amazon ECR → EC2 GitHub Actions deployment workflow
DELIVERY
DATA → MODEL → API GITHUB → AWS
PROJECT TYPE Network Security / MLOps
MODEL WORKFLOW Scikit-learn / MLflow
API & CONTAINER FastAPI / Docker
CLOUD DELIVERY GitHub Actions / AWS
ENGINEERING REQUIREMENTSNS-05
R01

Data flow & validation

Trace the configured MongoDB ingestion, feature-store export, train/test split, schema checks, drift analysis and KNN imputation. Verify validation behavior against the implementation rather than assuming every check succeeds.

DATA PIPELINE
R02

Model evaluation

Document the five candidate classifiers, hyperparameter search and available train/test metrics. Review the current R²-based model-selection logic and report precision, recall and F1 with actual measured values when verified.

CLASSIFICATION QUALITY
R03

API serving & CI/CD

Explain the FastAPI training and CSV prediction routes, saved model artifacts, Docker image, GitHub Actions workflow, Amazon ECR registry and self-hosted deployment runner. Distinguish configured steps from meaningful automated tests.

API / CLOUD DELIVERY
R04

Monitoring & limitations

Assess MLflow metric tracking, the attempted statistical drift report, logging and failure handling. Identify gaps in live monitoring, validation, model evaluation and secret management without claiming unverified safeguards.

RELIABILITY / GOVERNANCE
REQUIREMENTS TO VERIFYR01 — R04
02/ PROBLEM & REQUIREMENTS
SECURITY ENGINEERING PROBLEM

Detect phishing. Prove the full pipeline.

A phishing-detection model is only one part of a dependable security solution. The data must be prepared and checked, candidate models must be evaluated appropriately, predictions must be served consistently, and delivery and monitoring claims must be backed by technical evidence.

01PROJECT OBJECTIVE

Document and assess the repository’s end-to-end workflow—from URL-feature data and model training to API predictions and cloud deployment. Make model quality, operational behavior, security risks and implementation limitations explicit.

CORE ENGINEERING SCOPE
01 Data ingestion → Validation → Transformation
02 Classifier training → Evaluation → API serving
03 CI/CD → Cloud deployment → Monitoring evidence

03 / ARCHITECTURE & SYSTEM DESIGN

From URL data to a deployed prediction service.

The system connects URL-feature data ingestion, preprocessing, candidate-model training and experiment tracking with an API-based prediction service. Containerization and cloud-delivery components support the deployment workflow. Model quality and operational monitoring must be assessed separately from the presence of these components.

CORE TECHNOLOGIES
Python Pandas / NumPy Scikit-learn MongoDB Atlas MLflow / DagsHub FastAPI Docker GitHub Actions Amazon ECR Amazon EC2 Amazon S3

System architecture

Data → Serving
01

Data ingestion

URL-feature dataset and configured MongoDB ingestion/export path.

DATA SOURCE
02

Validation & preprocessing

Schema checks, validation logic, data transformation and KNN imputation.

PREPARATION
03

Model training & tracking

Candidate classifiers, model-selection workflow and MLflow/DagsHub experiment tracking.

ML PIPELINE
04

Prediction API

FastAPI application exposes training and CSV-based prediction routes.

SERVING
05

Container & CI/CD

Docker packaging and GitHub Actions workflow for configured build and delivery steps.

AUTOMATION
06

Cloud delivery

Amazon ECR, EC2 deployment workflow and S3 artifact-sync components.

AWS

Evaluation & monitoring layer

EVIDENCE REQUIRED

MLflow/DagsHub supports experiment tracking. A complete evaluation should report verified classification metrics such as precision, recall, F1-score and a confusion matrix. The repository's drift-checking logic and operational monitoring require separate verification; experiment tracking alone does not establish live production monitoring.

↳ Architecture is based on components identified in the repository. Arrows describe the conceptual lifecycle, not proof that every stage has passed end-to-end testing. Section 06 will document measured evaluation results and available technical evidence.

04 / IMPLEMENTATION & CORE COMPONENTS

Every component has a job.

The implementation connects data ingestion and preparation with model training, experiment tracking, prediction serving and cloud delivery. Each component has a distinct responsibility in the end-to-end machine-learning workflow.

IMPLEMENTATION PRINCIPLE

Keep data processing, model development, API serving and deployment responsibilities identifiable. A component appearing in the repository does not by itself prove that the complete pipeline passed end-to-end validation.

COMPONENT / 01 Data ingestion

MongoDB Atlas

The data-ingestion component retrieves the phishing-detection dataset for downstream processing and model development.

Role: Data access
COMPONENT / 02 Preparation

Data validation

The pipeline includes schema and data checks, transformation steps and KNN-based imputation as part of preparation.

Role: Data quality and preprocessing
COMPONENT / 03 Model development

Training pipeline

The training code evaluates candidate classification models for the URL-feature dataset and selects a model through its configured selection logic.

Role: Model training and selection
COMPONENT / 04 Experiment tracking

MLflow + DagsHub

Experiment-tracking integration records model-development information. The selection metric and reported scores require careful interpretation, as detailed in the evaluation section.

Role: Experiment tracking
COMPONENT / 05 Prediction serving

FastAPI + Docker

FastAPI provides the prediction-service layer, while Docker packages the application and its runtime dependencies for container-based delivery.

Role: API and container packaging
COMPONENT / 06 Cloud delivery

GitHub Actions + AWS

The workflow integrates automated delivery with Amazon ECR and EC2; the project also includes S3 artifact-sync logic. Successful execution must be established from run evidence.

Role: Build and deployment workflow
05 / WORKFLOW & EXECUTION
MLOPS LIFECYCLE

From raw data to prediction.

The project connects dataset ingestion, validation, preprocessing, model training and experiment tracking with a FastAPI prediction service and an automated container-delivery workflow. Each stage produces an artifact or service used by the next stage.

EXECUTION PRINCIPLE

A configured pipeline is not the same as a fully verified pipeline. In particular, the repository's CI lint and unit-test steps currently print messages rather than execute actual linting or tests. Deployment success and runtime health should be supported by run logs and service checks, not inferred from configuration alone.

EXECUTION SEQUENCE 01 — 06
01

Ingest and split data

DATA SOURCE

The ingestion component exports records from MongoDB Atlas, writes a local feature-store CSV and splits the dataset into training and testing files.

DataIngestion → train.csv / test.csv
02

Validate the dataset

QUALITY CHECKS

The validation component checks the expected column count, compares training and testing distributions using a two-sample KS test and writes a drift report. The current implementation needs stronger validation and failure handling before this can be treated as a reliable blocking gate.

data_schema/schema.yaml
03

Transform the features

PREPROCESSING

The transformation stage separates features from the target, maps target labels from -1 to 0 and applies a KNN imputer fitted on training features. It saves transformed arrays and the fitted preprocessor.

KNNImputer → transformed arrays
04

Train and track models

MODEL PIPELINE

The trainer compares candidate classifiers, including Random Forest, Decision Tree, Gradient Boosting, Logistic Regression and AdaBoost. It records precision, recall and F1 metrics through MLflow/DagsHub and saves model artifacts. The model-selection logic requires careful review before its scores are treated as reliable classification evaluation.

ModelTrainer → model.pkl / preprocessor.pkl
05

Serve predictions and sync artifacts

API / STORAGE

FastAPI exposes a training route and a CSV-upload prediction route. Prediction loads the saved model and preprocessor, produces predictions and renders the resulting table. The training pipeline also contains S3 sync steps for artifacts and saved-model files.

/train · /predict · Amazon S3
06

Build, publish and deploy

CI / CD

A push to the main branch, except README-only changes, triggers GitHub Actions. The workflow builds a Docker image, pushes it to Amazon ECR, then uses a self-hosted runner to pull the image and run the container on port 8080. Successful execution must be confirmed from workflow logs and a live service check.

GitHub Actions → ECR → EC2
INTENDED OUTCOME

Model-backed prediction service

VERIFY THE PIPELINE

From raw data to detection.

An end-to-end MLOps implementation needs evidence across the data pipeline, model evaluation, API serving and delivery workflow. These project artifacts illustrate key components of the Network Security System without treating screenshots as proof that every stage has passed an end-to-end test.

01

Data and system flow

The architecture and MongoDB Atlas artifacts provide context for the system design and data-ingestion layer. Schema validation and drift handling still require reliable validation outcomes.

02

Model evaluation

The code calculates precision, recall and F1-score and logs model-related metrics. No verified numerical scores are presented here. The repository's use of R² for classifier selection should be reviewed and replaced with suitable classification metrics.

03

Serving and delivery

FastAPI documentation, GitHub Actions, ECR and EC2 artifacts illustrate the intended serving and delivery path. A screenshot alone does not confirm current API health or a successful fresh deployment.

Evidence-led engineering Model scores, repeatable test results, API behavior and live monitoring should be reported only when supported by reproducible outputs. Prometheus and Grafana are identified as future improvements, not verified live monitoring features.

ENGINEERING RESPONSIBLY

Secure the pipeline. Design for failure.

An end-to-end MLOps pipeline must protect credentials, validate incoming data, expose its API deliberately, and make deployment failures diagnosable. Reviewing the repository reveals important security and reliability boundaries that should be addressed before treating the system as production-ready.

CORE PRINCIPLE

Protect secrets, validate data, make failures visible, and verify model behavior before trusting the service.

ENGINEERING REVIEW 04 / FOCUS AREAS
01
SECRETS MANAGEMENT

Credentials & Access

The repository contains hard-coded DagsHub tracking credentials, and the application prints a MongoDB connection URL. Revoke or rotate exposed credentials, move secrets into environment variables or managed secret storage, and prevent sensitive values from appearing in logs or source control.

ROTATE & PROTECT SECRETS
02
API & INPUT VALIDATION

Control the Boundaries

The FastAPI application uses wildcard CORS and exposes a training route without visible authentication. CSV uploads should have explicit file-size, schema and content checks. Restrict browser origins where needed, protect sensitive operations, and return controlled errors for invalid requests.

VALIDATE EVERY REQUEST
03
DELIVERY RELIABILITY

Test Before Deployment

The GitHub Actions workflow includes lint and test steps that currently only echo messages rather than running actual checks. Deployment also uses the mutable latest image tag, while container replacement commands are commented out. Implement real automated tests, explicit image versions and repeatable deployment cleanup before relying on unattended releases.

VERIFY EACH RELEASE
04
MODEL RELIABILITY

Measure & Monitor

The code calculates precision, recall and F1-score, but the model-selection logic also uses R² for classification, which is not an appropriate primary classifier-selection metric. Evaluate with a confusion matrix and class-aware metrics. Dataset drift checks and operational health monitoring need reliable, observable outcomes before they can be trusted.

MEASURE MODEL & SERVICE HEALTH

What remains to be verified

These findings describe code-review observations and recommended improvements, not completed remediation. The repository identifies Prometheus, Grafana and additional drift monitoring as future work. No live monitoring dashboard, alerting setup, automated rollback, or comprehensive security audit is claimed here.

ENGINEERING ANALYSIS / 08

Technology decision matrix

04 COMPONENTS
01 Data MongoDB Atlas
02 Training MLflow / DagsHub
03 Serving FastAPI / Docker
04 Delivery ECR / EC2
EXPERIMENTS & ARTIFACTS

MLflow and DagsHub support experiment tracking, while Amazon S3 is used in the project’s artifact workflow. Tracking, storage and serving remain separate responsibilities.

TECHNOLOGY ENGINEERING VALUE TRADE-OFF
01 MongoDB Atlas

Managed data storage for the ingestion pipeline

External service dependency, credentials and data validation

02 MLflow + DagsHub

Experiment tracking and model-related metric logging

Credential management and correct model-selection metrics

03 FastAPI + Docker

API serving with a containerized application environment

Input validation, access control and image maintenance

04 Actions + ECR / EC2

Automated image delivery and a cloud deployment target

Workflow reliability, deployment cleanup and instance upkeep

DESIGN IMPLICATION

Connecting the data pipeline, experiment tracking, model-serving API and delivery workflow demonstrates an end-to-end engineering approach. Its reliability still depends on valid evaluation, secure configuration, repeatable deployments and observable runtime behavior.

SYSTEM DESIGN TRADE-OFFS

Every tool has a purpose. Every choice has a cost.

This Network Security System brings together data ingestion, model development, API serving and cloud delivery. The engineering value is not simply the number of tools used, but how each component contributes to a connected workflow and where its limitations need to be addressed.

A

Separate the responsibilities

Data ingestion, model training, experiment tracking, API serving and cloud delivery have different roles. Keeping these stages distinct makes the pipeline easier to inspect and maintain.

B

Automation needs real validation

GitHub Actions, Docker and ECR provide a delivery structure, but workflow automation alone does not prove model quality or deployment health. Real automated tests and reproducible evaluation are necessary before trusting a release.

C

Choose metrics that fit the task

Precision, recall, F1-score and a confusion matrix are useful for evaluating phishing classification. Using R² to select a classifier is a methodological limitation that should be corrected before drawing conclusions about model performance.

09 / RESULTS & REFLECTION ENGINEERING REVIEW

What the pipeline actually proves.

The repository brings together phishing-data processing, model training, experiment tracking, API serving and a cloud-oriented delivery workflow. Its code demonstrates an end-to-end implementation approach, but implementation alone does not establish model quality or production reliability.

∴

Engineering takeaway A working pipeline is only part of the result. Reliable phishing detection also requires valid evaluation, secure operation and measurable runtime behaviour.

SCIKIT-LEARN MLFLOW FASTAPI DOCKER AWS
REPOSITORY REVIEW

What the implementation contains

04 AREAS
01
DATA PIPELINE

Ingestion & preprocessing

The code includes data ingestion, validation, transformation and KNN-based imputation. Validation robustness still needs attention; the current checks do not establish complete schema integrity.

IN REPO
02
MODEL EVALUATION

Training & experiment tracking

Multiple classifiers, hyperparameter search and precision, recall and F1 calculations are present. No verified numerical model scores are presented here; R²-based classifier selection needs correction.

IN REPO
03
API SERVING

FastAPI prediction interface

The application defines a CSV-based prediction endpoint and loads saved preprocessing and model artifacts. This code does not, by itself, prove production readiness or reliable behaviour under load.

IN REPO
04
CI/CD & CLOUD

Container delivery workflow

GitHub Actions configuration covers image publication to Amazon ECR and deployment to EC2. The configured workflow still needs real automated tests and repeatable deployment verification.

CONFIGURED
ENGINEERING REVIEW / 01

Lessons & next improvements

L01

Evaluate the right way

Select classifiers using task-appropriate metrics. Review precision, recall, F1 and the confusion matrix before drawing conclusions about phishing detection.

L02

Validate the data contract

Check expected column names, data types, missing values and target labels. Make drift checks return reliable, actionable validation results.

L03

Make delivery repeatable

Replace placeholder CI checks with actual tests, use versioned image tags and verify safe repeat deployments and recovery procedures.

L04

Measure runtime behaviour

Add health checks, structured logs, operational monitoring and alerting. Treat model and data-drift monitoring as unverified until implemented and tested.

PROJECT HANDOFF

Trace the system. Improve what comes next.

The repository provides the source for reviewing how data ingestion, model training, experiment tracking, prediction serving and cloud delivery fit together. Use the code and documented artifacts to inspect the implementation rather than treating the architecture alone as proof of success.

01

Trace the data-to-model workflow

Review ingestion, validation, transformation, classifier training and experiment-tracking components. Follow how processed data and saved model artifacts are used.

02

Inspect serving and delivery

Read the FastAPI application, Dockerfile and GitHub Actions workflow to understand prediction serving, image publication and the configured EC2 deployment path.

03

Validate before drawing conclusions

Check the evaluation implementation and recorded outputs. The presence of metric calculations or workflow files does not establish verified model performance or successful automated tests.

POTENTIAL NEXT ITERATIONS
+

Replace R²-based classifier selection with an appropriate classification metric and report verified evaluation results.

+

Strengthen schema and drift validation, and add real automated tests to the CI workflow.

+

Add runtime health checks, actionable logs, monitoring and alerting; verify recovery behaviour through tests.

+

Move credentials into secure environment configuration and managed secrets, then rotate exposed credentials.

These are recommended next steps, not claims that the improvements are already implemented. Monitoring dashboards, alerts and verified model scores are not asserted here.

Scroll to Top