// This component runs on the server — never ships to the browser
async function UserProfile({ userId }: { userId: string }) {
  const user = await db.users.findUnique({ where: { id: userId } });
  const posts = await db.posts.findMany({ where: { authorId: userId } });

  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.bio}</p>
      <PostList posts={posts} />
    </div>
  );
}

// Server Component — 0 KB shipped to browser
async function ProductCatalog() {
  const products = await db.products.findMany({
    where: { active: true },
    orderBy: { createdAt: 'desc' },
  });

  return (
    <div className="grid grid-cols-3 gap-4">
      {products.map(p => (
        <div key={p.id}>
          <img src={p.imageUrl} alt={p.name} />
          <h3>{p.name}</h3>
          <p>${p.price}</p>
        </div>
      ))}
    </div>
  );
}

// Server Component (default in Next.js App Router)
async function Dashboard() {
  const stats = await getStats();  // Server-side data fetch

  return (
    <div>
      <h1>Dashboard</h1>
      <StatsDisplay stats={stats} />          {/* Server — no JS */}
      <InteractiveChart data={stats.chart} />  {/* Client — has JS */}
      <RecentActivity items={stats.recent} />  {/* Server — no JS */}
    </div>
  );
}

// Client Component (opt-in with "use client")
"use client";
import { useState } from 'react';

function InteractiveChart({ data }) {
  const [timeRange, setTimeRange] = useState('7d');
  // ... interactive chart logic
}

async function Page() {
  return (
    <div>
      <Header />  {/* Renders immediately */}

      <Suspense fallback={<Skeleton />}>
        <SlowDataSection />  {/* Streams in when ready */}
      </Suspense>

      <Suspense fallback={<Skeleton />}>
        <AnotherSlowSection />  {/* Streams in independently */}
      </Suspense>

      <Footer />  {/* Renders immediately */}
    </div>
  );
}

async function CreatePost() {
  async function createPost(formData: FormData) {
    "use server";
    const title = formData.get('title') as string;
    const content = formData.get('content') as string;
    await db.posts.create({ data: { title, content } });
    revalidatePath('/posts');
    redirect('/posts');
  }

  return (
    <form action={createPost}>
      <input name="title" required />
      <textarea name="content" required />
      <button type="submit">Publish</button>
    </form>
  );
}

npx create-next-app@latest --app
# All components are Server Components by default
# Add "use client" only when you need interactivity

import { Redis } from '@upstash/redis';

const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL,
  token: process.env.UPSTASH_REDIS_REST_TOKEN,
});

// Works in Vercel Edge, Cloudflare Workers, Deno Deploy
await redis.set('user:1', { name: 'Alice', role: 'admin' });
const user = await redis.get('user:1');

import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(10, '10 s'),
});

// In your API handler
const { success, remaining } = await ratelimit.limit(userId);
if (!success) return new Response('Too many requests', { status: 429 });

import { Client } from '@upstash/qstash';

const qstash = new Client({ token: process.env.QSTASH_TOKEN });

// Send message to your endpoint (with retries)
await qstash.publishJSON({
  url: 'https://myapp.com/api/process',
  body: { orderId: '123', action: 'fulfill' },
  retries: 3,
  delay: '10s',
});

// Schedule recurring tasks
await qstash.schedules.create({
  destination: 'https://myapp.com/api/cleanup',
  cron: '0 * * * *', // Hourly
});

import { Index } from '@upstash/vector';

const index = new Index({
  url: process.env.UPSTASH_VECTOR_REST_URL,
  token: process.env.UPSTASH_VECTOR_REST_TOKEN,
});

// Store embeddings
await index.upsert([
  { id: 'doc1', vector: embedding1, metadata: { title: 'React Guide' } },
  { id: 'doc2', vector: embedding2, metadata: { title: 'Vue Tutorial' } },
]);

// Semantic search
const results = await index.query({
  vector: queryEmbedding,
  topK: 5,
  includeMetadata: true,
});

import { Kafka } from '@upstash/kafka';

const kafka = new Kafka({
  url: process.env.UPSTASH_KAFKA_REST_URL,
  username: process.env.UPSTASH_KAFKA_REST_USERNAME,
  password: process.env.UPSTASH_KAFKA_REST_PASSWORD,
});

const producer = kafka.producer();
await producer.produce('orders', JSON.stringify({ orderId: '123' }));

const consumer = kafka.consumer();
const messages = await consumer.consume({ consumerGroupId: 'group1', topic: 'orders' });

npm install @upstash/redis @upstash/ratelimit @upstash/qstash

-- SQL: Get users with their posts and comments count
SELECT u.id, u.name,
  (SELECT json_agg(json_build_object(
    'title', p.title,
    'comment_count', (SELECT COUNT(*) FROM comments c WHERE c.post_id = p.id)
  )) FROM posts p WHERE p.author_id = u.id) as posts
FROM users u WHERE u.name ILIKE '%alice%';

# EdgeQL: Same query
SELECT User {
  name,
  posts: {
    title,
    comment_count := count(.comments)
  }
} FILTER .name ILIKE '%alice%';

# dbschema/default.esdl
module default {
  type User {
    required name: str;
    required email: str {
      constraint exclusive;
    };
    multi posts := .<author[IS Post];
    created_at: datetime {
      default := datetime_current();
    };
  }

  type Post {
    required title: str;
    required content: str;
    required author: User;
    multi comments: Comment;
    multi tags: str;
    published: bool {
      default := false;
    };
  }

  type Comment {
    required body: str;
    required author: User;
    created_at: datetime {
      default := datetime_current();
    };
  }
}

npx @edgedb/generate edgeql-js

import e from './dbschema/edgeql-js';
import { createClient } from 'edgedb';

const client = createClient();

// Fully typed queries
const users = await e.select(e.User, (user) => ({
  name: true,
  email: true,
  posts: (post) => ({
    title: true,
    comment_count: e.count(post.comments),
    filter: e.op(post.published, '=', true),
  }),
  filter: e.op(user.name, 'ilike', '%alice%'),
})).run(client);

// users is typed as Array<{ name: string, email: string, posts: Array<{ title: string, comment_count: number }> }>

using extension auth;

module default {
  type User {
    required name: str;
    required identity: ext::auth::Identity;
  }
}

# Generate migration from schema changes
edgedb migration create

# Apply
edgedb migrate

# Squash migrations
edgedb migration squash

edgedb ui
# Opens browser with:
# - Schema viewer
# - Data browser
# - Query editor with autocomplete
# - Migration history

# Install
curl --proto '=https' --tlsv1.2 -sSf https://sh.edgedb.com | sh

# Create project
edgedb project init

# Start UI
edgedb ui

Here's a simple system I've developed over the years that helps me never miss a deadline, even when juggling multiple projects. It's a practical approach tailored for developers and freelancers, combining a few powerful tools with some solid time management techniques.

## Prioritization: The Foundation of Success

Starting off, prioritize your tasks effectively. The Eisenhower Box is an excellent method to categorize tasks based on their urgency and importance. By doing so, you ensure that you tackle high-priority tasks promptly without getting overwhelmed by less pressing matters.

## Breaking Down Large Projects

Large projects can often seem intimidating, but breaking them down into smaller, manageable chunks makes them easier to handle. This technique is commonly known as "divide and conquer." For example, if you're working on a complex feature for an application:

Breaking a project down in this way allows you to focus on one task at a time, making it more achievable and less overwhelming.

## Time Blocking: Mastering Your Calendar

Time blocking is an effective strategy for managing your time efficiently. Assign specific time slots to tasks throughout the day, ensuring that you dedicate concentrated blocks of time to each task without interruptions. For example, I block out two hours every morning for focused coding and save email checking for designated breaks.

## Using Tools to Stay Organized

Staying organized is crucial in meeting deadlines. Here are some popular tools that can help you manage your workload:

1. **Trello**: A flexible project management tool that allows you to organize tasks into boards, lists, and cards. Great for tracking the progress of multiple projects at once.

2. **Jira**: Popular among Agile teams for managing software development tasks, Jira offers features like customizable workflows, issue tracking, and reporting.

3. **Notion**: A powerful all-in-one workspace that includes note-taking, task management, wikis, databases, and more. It's perfect for freelancers who need an organized hub for their projects.

## Establishing a Buffer Zone

Always build a buffer zone into your schedule to accommodate unexpected issues that might arise. This ensures you stay on track even when obstacles present themselves. I usually allocate an extra day or two for each project, which gives me room to maneuver if necessary.

## The Power of Focus

Avoid distractions during focused work sessions by turning off notifications, using browser extensions like Freedom or Cold Turkey, and practicing mindfulness techniques to maintain your focus. Remember, uninterrupted work allows you to complete tasks more quickly and with fewer errors.

## Setting Realistic Deadlines

When estimating project timelines, err on the side of caution. It's better to under-promise and over-deliver than the other way around. By setting realistic deadlines, you reduce the chances of missing them or compromising quality.

## Takeaway

Developing a system that prevents missed deadlines is crucial for any developer or freelancer. Prioritize tasks effectively, break down large projects, time block your calendar, use organizational tools like Trello, Jira, and Notion, establish a buffer zone, stay focused, and set realistic deadlines. With these tips in hand, you're well on your way to mastering deadline management and delivering top-notch work consistently.

import { NodeSDK } from '@opentelemetry/sdk-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'http://localhost:4318/v1/traces',
    // Switch backends by changing this URL:
    // Grafana Tempo, Jaeger, Zipkin, Datadog, Honeycomb, etc.
  }),
  instrumentations: [getNodeAutoInstrumentations()],
});

sdk.start();

npm install @opentelemetry/auto-instrumentations-node

import { trace } from '@opentelemetry/api';

const tracer = trace.getTracer('my-service');

async function processOrder(orderId: string) {
  return tracer.startActiveSpan('processOrder', async (span) => {
    span.setAttribute('order.id', orderId);

    const items = await tracer.startActiveSpan('fetchItems', async (childSpan) => {
      const result = await db.query('SELECT * FROM items WHERE order_id = $1', [orderId]);
      childSpan.setAttribute('items.count', result.length);
      childSpan.end();
      return result;
    });

    await tracer.startActiveSpan('chargePayment', async (childSpan) => {
      await stripe.charges.create({ amount: calculateTotal(items) });
      childSpan.end();
    });

    span.setStatus({ code: SpanStatusCode.OK });
    span.end();
  });
}

import { metrics } from '@opentelemetry/api';

const meter = metrics.getMeter('my-service');

const requestCounter = meter.createCounter('http_requests_total', {
  description: 'Total HTTP requests',
});

const latencyHistogram = meter.createHistogram('http_request_duration_ms', {
  description: 'HTTP request latency',
});

app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    requestCounter.add(1, { method: req.method, path: req.path, status: res.statusCode });
    latencyHistogram.record(Date.now() - start, { method: req.method });
  });
  next();
});

# otel-collector-config.yaml
receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:
    timeout: 5s

exporters:
  otlp/jaeger:
    endpoint: jaeger:4317
  prometheus:
    endpoint: 0.0.0.0:8889

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/jaeger]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

npm install @opentelemetry/sdk-node 
  @opentelemetry/auto-instrumentations-node 
  @opentelemetry/exporter-trace-otlp-http

LLM ──→ Hardcoded Tool A (custom REST client)
    ──→ Hardcoded Tool B (custom gRPC wrapper)
    ──→ Hardcoded Tool C (custom DB connector)
    ──→ Hardcoded Tool D (custom file reader)

LLM ──→ MCP Client ──→ MCP Server: Database
                   ──→ MCP Server: Search
                   ──→ MCP Server: Kubernetes
                   ──→ MCP Server: Slack
                   ──→ MCP Server: (anything)

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import * as k8s from "@kubernetes/client-node";

const server = new McpServer({
  name: "k8s-health",
  version: "1.0.0",
});

server.tool(
  "check_pod_status",
  "Check the health status of pods in a namespace",
  { namespace: { type: "string", description: "Kubernetes namespace" } },
  async ({ namespace }) => {
    const kc = new k8s.KubeConfig();
    kc.loadFromDefault();
    const k8sApi = kc.makeApiClient(k8s.CoreV1Api);

    const res = await k8sApi.listNamespacedPod({ namespace });
    const unhealthy = res.items.filter(
      (p) => p.status?.phase !== "Running" && p.status?.phase !== "Succeeded"
    );

    return {
      content: [
        {
          type: "text",
          text: unhealthy.length === 0
            ? `All pods in ${namespace} are healthy.`
            : `Found ${unhealthy.length} unhealthy pods:n` +
              unhealthy
                .map((p) => `- ${p.metadata?.name}: ${p.status?.phase}`)
                .join("n"),
        },
      ],
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

┌──────────────────────────────────────────────────────┐
│              Kubernetes Cluster                       │
│                                                      │
│  ┌──────────────────────────────────────────────┐    │
│  │       Ingress / Gateway API                  │    │
│  │  Inference Gateway · model-aware routing     │    │
│  └───────────────────┬──────────────────────────┘    │
│                      │                               │
│  ┌─────────────┐ ┌───┴──────────┐ ┌──────────────┐  │
│  │ Agent API   │─│MCP Server    │ │ Key Metrics  │  │
│  │ FastAPI +   │ │Pool          │ │ TTFT <500ms  │  │
│  │ LangGraph   │ │ mcp-postgres │ │ GPU >70%     │  │
│  └──────┬──────┘ │ mcp-search   │ │ Tool >99.5%  │  │
│         │        │ mcp-k8s      │ │ Cost -39%    │  │
│         │        └──────┬───────┘ └──────────────┘  │
│  ┌──────┴──────┐ ┌──────┴───────┐                    │
│  │ LLM Server  │ │ Vector DB   │                    │
│  │ vLLM + DRA  │ │ Weaviate    │                    │
│  │ Llama-70B   │ │ Hybrid Srch │                    │
│  └─────────────┘ └─────────────┘                    │
│                                                      │
│  ┌──────────────────────────────────────────────┐    │
│  │ Observability: OTel → Prometheus → Grafana   │    │
│  └──────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────┘

apiVersion: resource.k8s.io/v1beta2
kind: ResourceClaim
metadata:
  name: llm-inference-gpu
  namespace: ai-agents
spec:
  devices:
    requests:
    - name: gpu
      deviceClassName: gpu.nvidia.com
      selectors:
      - cel:
          expression: >
            device.attributes["gpu.nvidia.com"].memory >= 24000 &&
            device.attributes["gpu.nvidia.com"].productName.startsWith("A")
    constraints:
    - requests: ["gpu"]
      matchAttribute: "gpu.nvidia.com/numa-node"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-server
  namespace: ai-agents
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vllm-server
  template:
    metadata:
      labels:
        app: vllm-server
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:v0.7.3
        args:
        - "--model=meta-llama/Llama-3.3-70B-Instruct"
        - "--tensor-parallel-size=1"
        - "--max-model-len=8192"
        - "--enforce-eager"
        ports:
        - containerPort: 8000
        resources:
          claims:
          - name: llm-gpu
      resourceClaims:
      - name: llm-gpu
        resourceClaimTemplateName: llm-inference-gpu

apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferencePool
metadata:
  name: llm-pool
  namespace: ai-agents
spec:
  targetPortNumber: 8000
  selector:
    matchLabels:
      app: vllm-server
---
apiVersion: inference.networking.x-k8s.io/v1alpha2
kind: InferenceModel
metadata:
  name: agent-model
  namespace: ai-agents
spec:
  modelName: "agent-llama-70b"
  targetModels:
  - name: "meta-llama/Llama-3.3-70B-Instruct"
    weight: 100
  poolRef:
    name: llm-pool

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-postgres
  namespace: ai-agents
  labels:
    mcp-server: "true"
    mcp-tool: "database"
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mcp-postgres
  template:
    metadata:
      labels:
        app: mcp-postgres
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "9090"
    spec:
      serviceAccountName: mcp-postgres-sa
      containers:
      - name: mcp-server
        image: registry.internal/mcp-postgres:1.2.0
        env:
        - name: DB_HOST
          valueFrom:
            secretKeyRef:
              name: postgres-credentials
              key: host
        - name: MCP_TRANSPORT
          value: "streamable-http"
        ports:
        - containerPort: 3000  # MCP
        - containerPort: 9090  # Metrics
        resources:
          requests:
            cpu: 100m
            memory: 256Mi
          limits:
            cpu: 500m
            memory: 512Mi
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          periodSeconds: 5
      volumes:
      - name: tls-certs
        secret:
          secretName: mcp-tls

# OpenTelemetry Collector config for AI metrics
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317

processors:
  batch:
    timeout: 5s

exporters:
  prometheus:
    endpoint: 0.0.0.0:8889
    namespace: ai_agent

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

# Alert: Agent tool calls failing above threshold
(
  sum(rate(mcp_tool_call_errors_total[5m])) by (tool_name)
  /
  sum(rate(mcp_tool_call_total[5m])) by (tool_name)
) > 0.05

from circuitbreaker import circuit

@circuit(failure_threshold=3, recovery_timeout=30)
async def call_mcp_tool(server: str, tool: str, params: dict):
    async with mcp_client.connect(server) as client:
        result = await client.call_tool(tool, params)
        return result

# Check current NGINX Ingress version
kubectl get deployment -n ingress-nginx ingress-nginx-controller -o jsonpath='{.spec.template.spec.containers[0].image}'

# List all current Ingress resources
kubectl get ingress --all-namespaces
kubectl describe ingress <name> -n <namespace>

# Install Gateway API CRDs
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
spec:
  gatewayClassName: nginx
  listeners:
  - name: http
    protocol: HTTP
    port: 80
    allowedRoutes:
      namespaces:
        from: All
  - name: https
    protocol: HTTPS
    port: 443
    tls:
      mode: Terminate
      certificateRefs:
      - name: tls-secret

# Old Ingress approach
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web
            port:
              number: 8080

# New HTTPRoute (Gateway API)
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: example
spec:
  parentRefs:
  - name: my-gateway
  hostnames:
  - "example.com"
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /
    backendRefs:
    - name: web
      port: 8080

# Scan local image
trivy image myrepo/myimage:latest

# Scan with severity filter
trivy image --severity HIGH,CRITICAL myrepo/myimage:latest

# Generate JSON report
trivy image --format json -o report.json myrepo/myimage:latest

# Generate SBOM with Syft
syft myrepo/myimage:latest -o spdx > sbom.json

# Check against known vulnerabilities
trivy sbom sbom.json

# GitHub Actions example
- name: Scan base image
  run: |
    trivy image --severity HIGH ubuntu:22.04
    if [ $? -ne 0 ]; then
      echo "Vulnerable base image detected"
      exit 1
    fi

- name: Build and scan
  run: |
    docker build -t myapp:${{ github.sha }} .
    trivy image myapp:${{ github.sha }}

# Pull, scan, and push to private registry
docker pull ubuntu:22.04
trivy image ubuntu:22.04
docker tag ubuntu:22.04 private-registry.com/ubuntu:22.04
docker push private-registry.com/ubuntu:22.04