How TensorFlow Helps You Land a DevOps Engineer Job Faster

# pip install tensorflow
import numpy as np
import tensorflow as tf

# Tiny model for practice: predicts y from x
x = np.array([[1.0], [2.0], [3.0], [4.0]], dtype="float32")
y = np.array([[3.0], [5.0], [7.0], [9.0]], dtype="float32")

model = tf.keras.Sequential([tf.keras.Input(shape=(1,)), tf.keras.layers.Dense(1)])
model.compile(optimizer=tf.keras.optimizers.SGD(0.05), loss="mse")
model.fit(x, y, epochs=300, verbose=0)

# TensorFlow Serving expects models/<name>/<version>/
model.export("models/demo/1")
print("exported to models/demo/1")

models/
`-- demo/
    |-- 1/                  # first version
    |   |-- saved_model.pb
    |   `-- variables/
    `-- 2/                  # newer version (TF Serving serves the highest by default)
        |-- saved_model.pb
        `-- variables/

DevOps tasks: store versions safely, deploy a chosen version,
and roll back by serving an older one.

#!/usr/bin/env bash
# Serve the exported model with TensorFlow Serving (REST on 8501)
set -euo pipefail
docker run -d --name tf-demo -p 8501:8501 \
  -v "$PWD/models/demo:/models/demo" \
  -e MODEL_NAME=demo \
  tensorflow/serving

sleep 5
curl -s http://localhost:8501/v1/models/demo          # model status
curl -s -X POST http://localhost:8501/v1/models/demo:predict \
  -d '{"instances": [[5.0], [6.0]]}'                   # predictions

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tf-demo
spec:
  replicas: 2
  selector:
    matchLabels: { app: tf-demo }
  template:
    metadata:
      labels: { app: tf-demo }
    spec:
      containers:
        - name: serving
          image: registry.example.com/tf-demo:1   # serving image with the model baked in
          env: [{ name: MODEL_NAME, value: demo }]
          ports: [{ containerPort: 8501 }]
          readinessProbe:
            httpGet: { path: /v1/models/demo, port: 8501 }
          resources:
            requests: { cpu: 250m, memory: 512Mi }
            limits: { cpu: "1", memory: 1Gi }

# .github/workflows/model-release.yml
name: model-release
on:
  push:
    paths: ["models/**"]
jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Start TensorFlow Serving
        run: |
          docker run -d --name tf -p 8501:8501 \
            -v "$PWD/models/demo:/models/demo" -e MODEL_NAME=demo tensorflow/serving
          sleep 15
      - name: Smoke test prediction
        run: |
          curl -sf -X POST http://localhost:8501/v1/models/demo:predict \
            -d '{"instances": [[5.0]]}'
      - name: Build serving image
        run: docker build -t tf-demo:${{ github.sha }} .

import requests

URL = "http://localhost:8501/v1/models/demo:predict"

def sanity_check() -> None:
    r = requests.post(URL, json={"instances": [[1.0], [5.0], [10.0]]}, timeout=5)
    r.raise_for_status()
    preds = [p[0] for p in r.json()["predictions"]]
    assert len(preds) == 3, "wrong number of predictions"
    assert preds == sorted(preds), "outputs should increase with input for this model"
    print("sanity check passed:", [round(p, 2) for p in preds])

if __name__ == "__main__":
    sanity_check()

Project: Serve and release a TensorFlow model

- Small TensorFlow model exported as SavedModel (versions 1 and 2)
- TensorFlow Serving container with the model
- CI pipeline: smoke test, sanity check, image build and scan
- Kubernetes (kind) deployment with probes, limits, 2 replicas
- Rolling update from version 1 to 2, then rollback
- Prometheus metrics or logs with one latency alert
- README with architecture and commands

Runbook: release a new model version

1. Data team adds models/demo/<N>/ and opens a pull request
2. Pipeline runs smoke test and sanity check
3. Build and push serving image tagged with version
4. Roll out to Kubernetes; watch latency and errors
5. If errors rise: kubectl rollout undo deployment/tf-demo
6. Record the release: version, time, approver, result

Week 1  Docker and Kubernetes refresher
Week 2  TensorFlow basics: train and export a tiny model
Week 3  TensorFlow Serving locally; REST predictions
Week 4  Kubernetes deployment with probes and resources
Week 5  CI pipeline with smoke tests and image build
Week 6  Monitoring, rollout and rollback drills