Machine learning from Data to Model

Detailed Flow

┌──────────────────────────────┐
│ 1. Problem Understanding     │
│ Define business goal/problem │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 2. Data Collection           │
│ Gather raw data from sources │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 3. Data Understanding / EDA  │
│ Explore patterns & structure │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 4. Data Cleaning             │
│ Fix nulls, duplicates, noise │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 5. Data Preprocessing        │
│ Encode, scale, transform     │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 6. Feature Engineering       │
│ Create useful input features │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 7. Feature Selection         │
│ Keep most relevant features  │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 8. Train / Val / Test Split  │
│ Divide data for learning     │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 9. Model Selection           │
│ Choose suitable algorithm    │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 10. Model Training           │
│ Learn patterns from data     │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 11. Model Evaluation         │
│ Check performance metrics    │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 12. Hyperparameter Tuning    │
│ Improve model performance    │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 13. Model Validation         │
│ Confirm generalization       │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 14. Final Model Selection    │
│ Choose best-performing model │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 15. Deployment               │
│ Put model into production    │
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 16. Prediction / Inference   │
│ Model makes real-world output│
└──────────────┬───────────────┘
               ↓
┌──────────────────────────────┐
│ 17. Monitoring & Retraining  │
│ Track drift and improve      │
└──────────────────────────────┘

Step-by-Step Explanation

1) Problem Understanding

This is the starting point of every ML project.

What happens here:

• Understand the business problem
• Define what needs to be predicted
• Decide whether it is:
• Classification
• Regression
• Clustering
• Recommendation
• Forecasting

Example:

• Predict whether a customer will leave → Classification
• Predict house price → Regression
• Group similar customers → Clustering

Why it matters:

If the problem is not defined properly, even a great model becomes useless.

2) Data Collection

Once the problem is clear, you collect the data.

Sources of data:

• Databases
• CSV / Excel files
• APIs
• Sensors / IoT devices
• Logs
• Websites / scraping
• Cloud storage
• User input systems

Example:

For fraud detection:

• Transaction amount
• Merchant type
• Device ID
• Time of transaction
• Location

Why it matters:

Machine learning is only as good as the data it learns from.

3) Data Understanding / Exploratory Data Analysis (EDA)

Now you inspect and understand the data.

What happens here:

• Check number of rows and columns
• Understand feature types:
• numerical
• categorical
• datetime
• text
• Study distributions
• Detect patterns
• Find anomalies
• Understand relationships between variables

Common EDA tasks:

• Summary statistics
• Histograms
• Boxplots
• Correlation heatmaps
• Pairplots
• Class distribution checks

Example questions:

• Is the dataset balanced?
• Which columns have missing values?
• Are there outliers?
• Which features influence the target most?

Why it matters:

EDA helps you understand what the model will learn from.

4) Data Cleaning

Real-world data is usually messy.

What happens here:

• Handle missing values
• Remove duplicate rows
• Fix wrong entries
• Correct inconsistent formats
• Remove irrelevant columns
• Fix data type issues

Examples:

• Age column has blanks
• Salary column contains text values
• Same customer repeated 3 times
• Date format inconsistent

Common methods:

• Drop missing values
• Fill with mean / median / mode
• Remove duplicates
• Standardize formats

Why it matters:

Dirty data leads to poor and misleading models.

5) Data Preprocessing

This step prepares the data so algorithms can use it properly.

What happens here:

• Convert raw data into model-friendly format

Common preprocessing tasks:

a) Encoding categorical variables

Convert categories into numbers:

• Label Encoding
• One-Hot Encoding
• Ordinal Encoding

Example:

• Red, Blue, Green → 0,1,2
• City_Mumbai, City_Pune, City_Delhi

b) Feature Scaling

Make values comparable in magnitude:

• Standardization
• Normalization
• Min-Max Scaling

Example:

• Salary = 100000
• Age = 25 Without scaling, salary dominates.

c) Text preprocessing

For NLP:

• lowercase
• tokenization
• stopword removal
• stemming / lemmatization
• vectorization (TF-IDF, embeddings)

d) Date-time processing

Extract:

• day
• month
• year
• hour
• weekday
• weekend flag

Why it matters:

Many ML models require clean numerical input.

6) Feature Engineering

This is where you create better inputs for the model.

What happens here:

You derive new meaningful features from existing data.

Examples:

• Age from date of birth
• Total purchase = quantity × price
• Days since last login
• Transaction hour from timestamp
• BMI from weight and height

Why it matters:

Better features often improve performance more than changing the algorithm.

In many real-world projects, feature engineering matters more than model complexity.

7) Feature Selection

Not every column should be used.

What happens here:

You select the most useful features and remove weak/noisy ones.

Why do this?

• Reduce overfitting
• Improve training speed
• Improve interpretability
• Reduce noise

Methods:

• Correlation analysis
• Variance threshold
• Recursive Feature Elimination (RFE)
• SelectKBest
• Tree-based importance
• Lasso regularization

Example:

If “Customer ID” is unique for each row, it usually adds no predictive value.

8) Train / Validation / Test Split

Now divide the data properly.

Common split:

• Training set → teaches the model
• Validation set → helps tune the model
• Test set → checks final performance

Typical ratios:

• 70 / 15 / 15
• 80 / 10 / 10
• 80 / 20 (if no validation set)

Why it matters:

If you train and test on the same data, the model may memorize instead of learn.

Important:

This step helps measure generalization.

9) Model Selection

Now choose the right algorithm.

Depending on problem type:

Classification

• Logistic Regression
• Decision Tree
• Random Forest
• XGBoost
• SVM
• Naive Bayes
• Neural Networks

Regression

• Linear Regression
• Ridge / Lasso
• Random Forest Regressor
• XGBoost Regressor

Clustering

• K-Means
• DBSCAN
• Hierarchical Clustering

Deep Learning

• ANN
• CNN
• RNN / LSTM
• Transformers

Why it matters:

Different algorithms suit different problems and data types.

10) Model Training

Now the model learns patterns from the training data.

What happens here:

• Inputs (X) and target (y) are fed into the model
• Model finds relationships between features and output
• It minimizes error / loss

Example:

If input is:

• age
• income
• credit score

Output:

• loan approval

The model learns how these factors affect approval.

Why it matters:

This is the actual learning phase.

11) Model Evaluation

After training, check how well it performs.

For Classification

Common metrics:

• Accuracy
• Precision
• Recall
• F1-score
• ROC-AUC
• Confusion Matrix

For Regression

Common metrics:

• MAE
• MSE
• RMSE
• R² Score

For Clustering

Common metrics:

• Silhouette Score
• Davies-Bouldin Score
• Inertia

Why it matters:

A model is useful only if it performs well on unseen data.

12) Hyperparameter Tuning

Hyperparameters are settings chosen before training.

Examples:

• max_depth in Decision Tree
• n_estimators in Random Forest
• learning_rate in XGBoost
• C in SVM

Common tuning methods:

• Grid Search
• Random Search
• Bayesian Optimization

Why it matters:

Good tuning can significantly improve model performance.

13) Model Validation

This step checks whether the model is stable and reliable.

Common validation methods:

• Cross-validation (K-Fold CV)
• Stratified K-Fold
• Time Series Split (for sequential data)

Why it matters:

Validation helps ensure the model is not just lucky on one split.

14) Final Model Selection

Now compare all candidate models and choose the best one.

Selection based on:

• Accuracy / RMSE / business metric
• Simplicity
• Explainability
• Speed
• Cost
• Scalability

Example:

Sometimes a slightly less accurate model is preferred because:

• it is easier to explain
• faster to deploy
• less expensive

15) Deployment

Now the model is put into the real world.

Deployment options:

• Web API
• Mobile app
• Batch prediction pipeline
• Cloud endpoint
• Dashboard
• Internal business system

Example:

• Fraud model deployed to score each transaction in real time
• Recommendation model deployed in e-commerce app

Why it matters:

A model has value only when it is used.

16) Prediction / Inference

Now the deployed model starts making predictions on new data.

Examples:

• Spam or not spam
• Fraud or not fraud
• Price prediction
• Disease prediction
• Customer churn prediction

Why it matters:

This is where ML delivers business value.

17) Monitoring & Retraining

This is one of the most important real-world steps.

What happens here:

You continuously track:

• model accuracy
• drift in data
• drift in predictions
• latency
• failures
• fairness
• business impact

Why retraining is needed:

Over time, data changes.

Example:

A fraud model trained on last year’s fraud patterns may fail on new fraud patterns.

This includes:

• Model monitoring
• Drift detection
• Retraining pipeline
• Versioning
• Re-deployment

Why it matters:

Without monitoring, model performance will silently degrade.

Very Important Interview Point

Machine learning is not just model training.

It is a full lifecycle:

Problem → Data → Cleaning → Features → Training → Evaluation → Deployment → Monitoring

That is the real end-to-end ML pipeline.

Short Summary Version

Machine Learning Lifecycle

1. Problem Understanding
2. Data Collection
3. Data Understanding / EDA
4. Data Cleaning
5. Data Preprocessing
6. Feature Engineering
7. Feature Selection
8. Train / Validation / Test Split
9. Model Selection
10. Model Training
11. Model Evaluation
12. Hyperparameter Tuning
13. Model Validation
14. Final Model Selection
15. Deployment
16. Prediction / Inference
17. Monitoring & Retraining

Best One-Line Explanation

Machine Learning is the process of turning raw data into a trained model that can make useful predictions on new data.

Where SMOTE Fits in the ML Flow

Updated Flow Position

Problem Understanding
      ↓
Data Collection
      ↓
EDA / Data Understanding
      ↓
Data Cleaning
      ↓
Data Preprocessing
      ↓
Feature Engineering
      ↓
Feature Selection
      ↓
Train / Validation / Test Split
      ↓
Class Imbalance Check
      ↓
SMOTE / Resampling (Train Data Only)
      ↓
Model Training
      ↓
Evaluation
      ↓
Hyperparameter Tuning
      ↓
Validation
      ↓
Final Model
      ↓
Deployment
      ↓
Monitoring / Retraining

SMOTE in Machine Learning

1) What is SMOTE?

SMOTE = Synthetic Minority Over-sampling Technique

It is used when your dataset has class imbalance, meaning one class has far fewer examples than the other.

Example:

Fraud detection dataset:

• Non-Fraud = 98,000
• Fraud = 2,000

This is an imbalanced dataset.

If you train directly on this, the model may simply predict “Non-Fraud” for everything and still get high accuracy.

That’s misleading.

What SMOTE does:

SMOTE creates synthetic (artificial but realistic) minority class samples instead of just duplicating existing rows.

2) Why Do We Need SMOTE?

Without handling imbalance:

• Model becomes biased toward majority class
• Minority class is poorly learned
• Accuracy may look high but model is useless
• Recall for rare but important class becomes very low

Common use cases:

• Fraud detection
• Disease prediction
• Defect detection
• Loan default prediction
• Churn prediction
• Intrusion / anomaly detection

3) How SMOTE Works

SMOTE does not simply copy rows.

Instead, it creates new synthetic points between existing minority class points.

Basic idea:

Suppose minority points are:

• Point A = (10, 20)
• Point B = (12, 24)

SMOTE creates a new synthetic point somewhere between A and B, like:

• New point = (11, 22)

So the minority class gets more examples in feature space.

4) Simple Working Mechanism of SMOTE

Step-by-step:

1. Pick a minority class sample
2. Find its k nearest minority neighbors
3. Randomly choose one of those neighbors
4. Create a synthetic sample between the two points

Formula:

Where:

• = minority sample
• = one of its nearest minority neighbors
• = random value between 0 and 1

This generates a new synthetic point.

5) Where Should SMOTE Be Applied?

Correct place:

After:

• cleaning
• preprocessing
• feature engineering
• train/test split

Before:

• model training

6) Very Important Rule: Apply SMOTE Only on Training Data

Correct

Split Data → Apply SMOTE on Train Set Only → Train Model → Test on Original Test Set

Wrong

Apply SMOTE on Full Dataset → Then Split

Why this is wrong:

This causes data leakage.

Because synthetic points created from training information may leak into test data, giving unrealistically high performance.

Interview point:

Never apply SMOTE before train-test split.

That is one of the most commonly asked practical ML questions.

7) Types of Imbalance Handling (Before SMOTE Types)

Before learning SMOTE variants, understand the broad imbalance strategies:

A) Random Oversampling

Increase minority class by duplicating samples.

Example:

Fraud class rows are repeated multiple times.

Pros:

• Very simple
• Works sometimes

Cons:

• Causes overfitting
• Repeats same information

B) Random Undersampling

Reduce majority class by removing samples.

Example:

Keep fewer “non-fraud” rows.

Pros:

• Faster training
• Simpler data

Cons:

• Can lose useful information

C) Synthetic Oversampling (SMOTE family)

Create new artificial minority samples.

Pros:

• Better than simple duplication
• Helps model learn minority boundary better

Cons:

• Can create noisy or unrealistic points if used badly

8) Main Types of SMOTE

Now the important part.

Type 1: Basic / Regular SMOTE

This is the standard SMOTE.

How it works:

• Finds minority neighbors
• Generates synthetic samples between them

Best when:

• Minority class is somewhat clustered
• Data is not extremely noisy

Limitation:

• Can create synthetic points in unsafe or overlapping regions

Type 2: Borderline-SMOTE

This is one of the most useful variants.

Idea:

Instead of generating samples everywhere, it focuses on minority points near the decision boundary.

These are the “difficult” cases — the ones near majority class samples.

Why useful:

These are the points the model struggles with most.

Variants:

• Borderline-SMOTE1
• Borderline-SMOTE2

Best when:

• Classes overlap
• Boundary learning is important

Limitation:

Can still generate noisy samples if boundary is very messy.

Type 3: SVM-SMOTE

This uses Support Vector Machine ideas.

How it works:

• Identifies support vectors near class boundary
• Generates synthetic samples around those difficult areas

Best when:

• Boundary is complex
• You want smarter boundary-focused oversampling

Limitation:

• More computationally expensive
• Sensitive to noisy data

Type 4: ADASYN (Adaptive Synthetic Sampling)

Very commonly discussed along with SMOTE.

Full form:

Adaptive Synthetic Sampling

How it works:

ADASYN creates more synthetic samples for harder-to-learn minority points and fewer for easier ones.

Key idea:

Focus more on difficult minority areas.

Best when:

• Minority class is highly uneven
• Some minority regions are harder than others

Limitation:

Can over-focus on noisy points and create bad synthetic data.

Type 5: KMeans-SMOTE

This is more advanced and often better in practice.

How it works:

1. Cluster data using K-Means
2. Identify minority-dense clusters
3. Apply SMOTE within good clusters

Why useful:

Prevents oversampling in poor or noisy regions.

Best when:

• Data has multiple sub-groups
• Minority class is spread across clusters

Limitation:

Needs more tuning and understanding

Type 6: SMOTE-NC

Full form:

SMOTE for Nominal and Continuous features

Used when your data contains both:

• numerical features
• categorical features

Example:

• Age → numerical
• Gender → categorical
• City → categorical
• Income → numerical

Why needed:

Regular SMOTE is designed mainly for numeric spaces and can fail on categorical variables.

Best when:

Mixed-type tabular data is present.

Type 7: SMOTE-ENN

This is a hybrid method.

Full form:

SMOTE + Edited Nearest Neighbors

How it works:

1. First apply SMOTE
2. Then remove noisy / ambiguous samples using ENN

Why useful:

It not only adds minority samples but also cleans the dataset.

Best when:

• There is class overlap
• Noise is present

Benefit:

Often gives cleaner decision boundaries.

Type 8: SMOTE-Tomek

Another hybrid method.

Full form:

SMOTE + Tomek Links

How it works:

1. Apply SMOTE
2. Remove Tomek links (borderline confusing pairs from opposite classes)

Why useful:

Helps reduce overlap between classes.

Best when:

• Classes are mixed at boundary
• You want a cleaner dataset

Quick Comparison of SMOTE Types

| Type             | Main Idea                                        | Best Use                   | Risk                      |
| ---------------- | ------------------------------------------------ | -------------------------- | ------------------------- |
| Regular SMOTE    | Create synthetic points between minority samples | Basic imbalance problems   | May create overlap        |
| Borderline-SMOTE | Focus on difficult boundary points               | Overlapping classes        | Can amplify noisy borders |
| SVM-SMOTE        | Use support vectors near boundary                | Complex class boundaries   | More computational cost   |
| ADASYN           | Create more samples for hard minority points     | Uneven minority difficulty | Can oversample noise      |
| KMeans-SMOTE     | Oversample inside meaningful clusters            | Clustered data             | More tuning needed        |
| SMOTE-NC         | Handle categorical + numeric features            | Mixed tabular data         | Needs proper setup        |
| SMOTE-ENN        | SMOTE + noise cleaning                           | Noisy/overlapping data     | Can remove useful points  |
| SMOTE-Tomek      | SMOTE + overlap cleanup                          | Boundary overlap problems  | May not fix all noise     |

10) Main Problems / Issues with SMOTE

This is the most important practical section.

Issue 1: Overfitting Risk

Even though SMOTE creates synthetic points, the new data is still derived from existing minority patterns.

Problem:

The model may learn too specifically around synthetic patterns.

Happens when:

• Dataset is very small
• Minority class is too sparse
• Too much oversampling is applied

How to deal with it:

• Don’t oversample blindly to exact balance every time
• Try partial balancing (not always 50:50)
• Use cross-validation
• Use regularized models
• Compare with class weighting

Issue 2: Synthetic Noise Creation

If minority class contains noisy or incorrect points, SMOTE may create more bad data around bad data.

Problem:

Garbage in → more synthetic garbage out

Example:

If one fraud row is actually mislabeled, SMOTE may generate more synthetic fraud samples around it.

How to deal with it:

• Clean data before SMOTE
• Detect outliers first
• Use SMOTE-ENN or SMOTE-Tomek
• Consider anomaly detection before oversampling

Issue 3: Class Overlap

SMOTE can create synthetic minority samples in regions where majority class already exists.

Problem:

This confuses the model.

Example:

Fraud and non-fraud points are already mixed in one area, and SMOTE creates even more overlap.

How to deal with it:

• Use Borderline-SMOTE
• Use SMOTE-Tomek
• Use SMOTE-ENN
• Visualize class separation if possible

Issue 4: Not Good for Extremely Sparse Minority Class

If there are too few minority examples, SMOTE may not have enough meaningful neighbors to generate realistic points.

Problem:

Generated points may not represent reality.

How to deal with it:

• Collect more real minority samples if possible
• Try class weighting instead
• Try anomaly detection approaches
• Use domain knowledge

Issue 5: Poor for High-Dimensional Data

In very high-dimensional spaces, nearest neighbors become less meaningful.

Problem:

SMOTE relies on nearest neighbors, but in high dimensions distance becomes less reliable.

Example:

Text vectors, embeddings, sparse TF-IDF spaces

How to deal with it:

• Reduce dimensionality first (PCA / feature selection)
• Avoid naive SMOTE on sparse NLP vectors
• Use class weights instead in some cases

Issue 6: Bad for Time Series / Sequential Data

Regular SMOTE ignores time order.

Problem:

It creates synthetic points without respecting temporal relationships.

Example:

Fraud transactions over time, stock prices, sensor signals

Why dangerous:

You may create unrealistic sequence patterns.

How to deal with it:

• Avoid standard SMOTE on raw time series
• Use sequence-aware methods
• Use time-based splitting
• Use class weighting / anomaly detection instead
• Very important interview point: Do not casually use SMOTE on time series data.

Issue 7: Can Distort Original Data Distribution

If oversampling is aggressive, the training data may no longer reflect real-world frequency.

Problem:

Model becomes too optimistic about rare class occurrence.

Example:

Real fraud rate = 2% After SMOTE training set may become 40–50%

How to deal with it:

• Evaluate on original untouched test set
• Focus on business metrics
• Tune classification threshold after training
• Don’t judge only by accuracy

Issue 8: Evaluation Becomes Misleading if Done Incorrectly

This happens if you apply SMOTE incorrectly or evaluate on oversampled test data.

Problem:

Metrics look amazing but fail in production.

How to deal with it:

• Keep validation/test sets untouched
• Use stratified split
• Use PR-AUC, Recall, Precision, F1
• Check confusion matrix
• Use business-driven thresholds

11) Best Practices for Using SMOTE

This is the part interviewers love.

Best Practice 1: Apply SMOTE only after train-test split

This avoids leakage.

Best Practice 2: Use SMOTE only on training data

Never on validation/test.

Best Practice 3: Use proper metrics

For imbalanced data, avoid relying only on accuracy.

Better metrics:

• Precision
• Recall
• F1-score
• PR-AUC
• ROC-AUC
• Confusion Matrix
• Balanced Accuracy

Best Practice 4: Compare with Class Weights

Sometimes class weighting works better than SMOTE.

Example:

• Logistic Regression with class_weight='balanced'
• Random Forest with class weights
• XGBoost with scale_pos_weight

This is often a very good real-world alternative.

Best Practice 5: Try multiple resampling strategies

Don’t assume SMOTE is automatically best.

Compare:

• No resampling
• Random Oversampling
• SMOTE
• SMOTE-Tomek
• SMOTE-ENN
• Class Weights

Then choose based on validation results.

Best Practice 6: Use Pipelines

Apply SMOTE inside cross-validation pipeline so there is no leakage.

This is the cleanest production-style approach.

12) When NOT to Use SMOTE

Do not blindly use SMOTE in these cases:

Avoid or be careful when:

• Data is very noisy
• Minority class is extremely tiny
• Data is high-dimensional sparse text
• Time series / sequential data
• Class boundary is highly irregular
• Labels are unreliable

13) SMOTE vs Class Weighting

Very important interview comparison.

| Aspect                       | SMOTE                           | Class Weighting                              |
| ---------------------------- | ------------------------------- | -------------------------------------------- |
| What it does                 | Adds synthetic minority samples | Increases minority class importance in loss  |
| Changes dataset?             | Yes                             | No                                           |
| Risk                         | Synthetic noise / overlap       | Sometimes insufficient minority learning     |
| Best for                     | Tabular imbalanced data         | Many models, especially linear/tree boosting |
| Good for time series?        | Usually no                      | Safer                                        |
| Good for sparse NLP vectors? | Usually not ideal               | Better often                                 |

Practical answer: In many production systems, I would compare SMOTE + model training against class weighting, and choose based on validation performance and business cost.

That is a very strong interview answer.

14) Best Practical Workflow for Imbalanced Data

Here is the best end-to-end flow:

Raw Data
   ↓
EDA
   ↓
Check Class Distribution
   ↓
Clean + Preprocess
   ↓
Train/Test Split
   ↓
Apply SMOTE only on Train Data
   ↓
Train Model
   ↓
Evaluate on Original Test Data
   ↓
Tune Threshold
   ↓
Deploy
   ↓
Monitor Minority-Class Performance

15) Strong Interview Answer

If interviewer asks:

“How do you handle imbalanced data?”

You can answer:

First, I check class distribution and confirm whether imbalance is actually affecting model performance. Then I evaluate using appropriate metrics like precision, recall, F1, PR-AUC, and confusion matrix rather than only accuracy. If needed, I try techniques such as class weighting, random oversampling, undersampling, and SMOTE variants like Borderline-SMOTE or SMOTE-ENN. I apply SMOTE only on the training set after the train-test split to avoid data leakage. Finally, I compare approaches through cross-validation and choose the method that performs best on untouched validation/test data and aligns with business cost.

That is a very strong real-world answer.

SMOTE helps balance imbalanced datasets by creating synthetic minority class samples, but it must be applied carefully to avoid leakage, noise, overlap, and misleading evaluation.

Thank you for diving into this post. I hope this content helps in better understanding. If the content helped you, your claps and a follow on Medium would mean a lot — they help this knowledge reach more readers and keep me motivated to write more. Really appreciate your time and support!!!