PyTorch or Postman First? What Beginners Should Pick

A simple PyTorch training loop:

import torch
import torch.nn as nn
import torch.optim as optim

model = nn.Sequential(
    nn.Linear(784, 128),
    nn.ReLU(),
    nn.Linear(128, 10)
)

optimizer = optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()

for epoch in range(5):
    model.train()
    for x, y in train_loader:
        optimizer.zero_grad()
        logits = model(x)
        loss = loss_fn(logits, y)
        loss.backward()
        optimizer.step()
    print(f"Epoch {epoch+1}, loss={loss.item():.4f}")

What this does:
• Builds a small neural network
• Trains it on data in batches
• Updates weights via backpropagation
• Prints training loss per epoch

The work is mostly:
• Preparing and cleaning datasets
• Designing and tuning models
• Evaluating results carefully
• Deploying and monitoring models

What an ML engineer does daily:

MORNING
• Review training runs from overnight
• Investigate a model that is
  underperforming on a subset of data
• Update evaluation metrics

MIDDAY
• Write preprocessing code
• Fine-tune a pretrained model
• Run experiments with different
  configurations

AFTERNOON
• Deploy a model to a staging
  endpoint
• Work with data engineers on data
  quality issues
• Document results and findings

The day is a mix of:
✓ Code writing (mostly Python)
✓ Data work (cleaning, exploration)
✓ Experimentation and evaluation
✓ Collaboration with data and
  product teams

If you enjoy training models, thinking
about data quality and evaluating
results carefully, this career fits well.

A basic Postman test (JavaScript):

// Request: GET {{baseUrl}}/api/users/1

// Tests tab:
pm.test("Status is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response has user id", function () {
    const json = pm.response.json();
    pm.expect(json).to.have.property("id", 1);
    pm.expect(json.email).to.include("@");
});

pm.test("Response time is under 500ms", function () {
    pm.expect(pm.response.responseTime)
      .to.be.below(500);
});

What this does:
• Sends an HTTP request
• Checks the status code
• Validates the response body structure
• Checks response time
• Reports pass/fail in the collection runner

The work is mostly:
• Designing API test cases
• Writing assertions
• Managing environments and variables
• Running collections in CI (via Newman)
• Reporting failures clearly

What an API tester does daily:

MORNING
• Review failed API tests from the CI run
• Investigate a 500 error in the staging
  environment
• Update collection tests for a new API
  version

MIDDAY
• Write new tests for a feature being built
• Chain requests to test a full flow
• Coordinate with the backend developer
  on edge cases

AFTERNOON
• Run the full API regression suite
• Report defects with request/response
  evidence
• Attend sprint ceremonies

The day is a mix of:
✓ Test design and debugging
✓ Working with HTTP, status codes,
  auth headers, JSON
✓ Collaboration with backend and QA teams
✓ Reporting and evidence

Note: Postman does involve scripting
(JavaScript assertions), but it is not
a general-purpose programming role.

A one-week test to decide between them:

DAY 1–3: PYTORCH
• Install Python and PyTorch
• Load a small dataset (e.g. MNIST)
• Train a tiny model for one epoch
• Notice how you feel while debugging
  the training loop

DAY 4–5: POSTMAN
• Install Postman
• Call a public API (e.g. jsonplaceholder)
• Add an assertion test
• Notice how you feel while testing

DAY 6–7: REFLECT
• Which session felt more natural?
• Which one would you still do if nobody
  paid you?
• Which kind of work would you enjoy
  doing every day?

The answer is usually obvious after
one week of actually doing the work
instead of reading about it.

Do not decide from YouTube videos alone —
you will be watching, not doing.

Bad reasons to pick one over the other:

✗ "I heard ML pays more"
  PyTorch-based roles do pay more at
  senior levels, but entry is much harder
  and many aspirants never break in.

✗ "Postman is easier"
  Postman is easier to start. Becoming a
  strong API tester takes as much effort
  as becoming a strong ML engineer —
  just in a different direction.

✗ "AI will replace testing"
  AI is changing testing, not replacing
  it. AI is also changing ML engineering.
  Neither field is immune.

✗ "You need a PhD for ML"
  Not for applied ML roles. PhDs matter
  for research-track positions, not for
  most ML engineering jobs.

✗ "My friend does ML"
  Your friend's preference is not your
  preference.

The one good reason:
You tried both briefly and one felt like
work you would choose to do — not work
you would avoid.

PyTorch — 90-day plan:

WEEKS 1–4: FOUNDATIONS
• Python: functions, pandas, numpy
• ML basics: train/test split, loss,
  metrics
• Your first model with scikit-learn

WEEKS 5–8: PYTORCH
• Tensors, autograd, device handling
• Training loops and evaluation
• Fine-tuning a pre-trained model
• Saving and loading models

WEEKS 9–10: PROJECT
• Fine-tune a model on real data
• Report precision / recall / F1
• Explain failure cases

WEEKS 11–12: JOB SEARCH
• Deploy the model behind an API
• Publish on GitHub with README
• Apply to 25 ML/DL roles
• Practice ML interview questions

Hardware:
• Weeks 1–8: CPU is fine
• Weeks 9–12: free Colab/Kaggle GPU

Portfolio artifact:
One fine-tuned model, deployed behind an
API, with honest evaluation and failure
analysis.

Postman — 90-day plan:

WEEKS 1–4: FUNDAMENTALS
• HTTP methods, status codes, headers
• Postman UI: requests, params, body
• Variables and environments
• Basic tests

WEEKS 5–8: TESTING DEPTH
• Assertions (status, body, schema)
• Chaining requests (auth tokens)
• Collection runner
• Pre-request scripts
• Negative and edge-case testing

WEEKS 9–10: PROJECT
• Build a complete test suite for a
  public API (jsonplaceholder or a
  known sandbox)
• Organise into collections and folders
• Document test strategy

WEEKS 11–12: JOB SEARCH
• Add Newman + GitHub Actions CI
• Publish collection to GitHub with README
• Write QA-focused resume bullets
• Apply to 25 QA / API testing roles

Portfolio artifact:
One well-organised collection with CI,
documentation and evidence of test design.