Why Every DevOps Engineer Should Learn TensorFlow in 2026

# train_and_export.py  (TensorFlow 2.16+ with Keras 3)
import numpy as np
import tensorflow as tf

x = np.random.rand(500, 4).astype("float32")
y = (x.sum(axis=1) * 10).astype("float32")

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(4,)),
    tf.keras.layers.Dense(16, activation="relu"),
    tf.keras.layers.Dense(1),
])
model.compile(optimizer="adam", loss="mse")
model.fit(x, y, epochs=5, verbose=0)

# Export a SavedModel that TensorFlow Serving can load.
# The number is the model version.
model.export("models/price/1")

models/
└── price/            <- model name
    ├── 1/            <- version 1
    │   ├── saved_model.pb
    │   └── variables/
    └── 2/            <- version 2 (next release)
        ├── saved_model.pb
        └── variables/

TensorFlow Serving loads the highest version
number by default. Rolling back can be as simple
as removing or renaming the newest folder.

# Serve the exported model locally
docker run --rm -p 8501:8501 \
  --mount type=bind,source="$(pwd)/models/price",target=/models/price \
  -e MODEL_NAME=price \
  tensorflow/serving

# Check that the model is loaded
curl http://localhost:8501/v1/models/price

# Send a prediction request (4 features per row)
curl -X POST http://localhost:8501/v1/models/price:predict \
  -H "Content-Type: application/json" \
  -d '{"instances": [[0.2, 0.4, 0.1, 0.9], [0.5, 0.5, 0.5, 0.5]]}'

# Response shape:
# {"predictions": [[...], [...]]}

# Dockerfile — bake model version 1 into the image
FROM tensorflow/serving
COPY models/price /models/price
ENV MODEL_NAME=price

# docker build -t registry.example.com/price-model:v1 .
# docker push registry.example.com/price-model:v1

apiVersion: apps/v1
kind: Deployment
metadata:
  name: price-model
spec:
  replicas: 2
  selector:
    matchLabels:
      app: price-model
  template:
    metadata:
      labels:
        app: price-model
    spec:
      containers:
        - name: serving
          image: registry.example.com/price-model:v1
          ports:
            - containerPort: 8501
          readinessProbe:
            httpGet:
              path: /v1/models/price
              port: 8501
            initialDelaySeconds: 10
          resources:
            requests:
              cpu: "500m"
              memory: "512Mi"
            limits:
              memory: "1Gi"

# .github/workflows/model-release.yml
name: model-release
on:
  push:
    tags: ["model-v*"]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Smoke test the model
        run: |
          docker run -d --name tfs -p 8501:8501 \
            -v "$PWD/models/price:/models/price" -e MODEL_NAME=price tensorflow/serving
          sleep 15
          curl -sf http://localhost:8501/v1/models/price
      - name: Build image
        run: docker build -t price-model:${{ github.ref_name }} .

MODEL RELEASE CHECKLIST

[ ] Model version number agreed with ML team
[ ] SavedModel loads in TensorFlow Serving locally
[ ] Sample predict request returns expected shape
[ ] Load test: latency at expected peak traffic
[ ] Resource requests/limits set from load test
[ ] Previous image tag recorded for rollback
[ ] ML team signs off on offline accuracy

MONITORING PLAN

System metrics (DevOps owns)
- Request rate, error rate, p95 latency
- CPU / memory per pod, restarts

Model metrics (shared with ML team)
- Distribution of input features vs training data
- Distribution of predictions over time
- Accuracy once real outcomes arrive

Alert owners
- Latency / errors      -> on-call DevOps
- Prediction drift      -> ML team