{"id":76990,"date":"2026-06-18T02:58:26","date_gmt":"2026-06-18T02:58:26","guid":{"rendered":"https:\/\/www.devopsschool.com\/blog\/?p=76990"},"modified":"2026-06-18T02:59:16","modified_gmt":"2026-06-18T02:59:16","slug":"forward-deployed-engineer-masterclass","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/blog\/forward-deployed-engineer-masterclass\/","title":{"rendered":"Forward Deployed Engineer Masterclass"},"content":{"rendered":"\n

I studied current FDE-style roles from Palantir, OpenAI, Anthropic, Google Cloud, Databricks, Together AI, Okta, Vercel, PayPay, Glean, Scale AI<\/strong> and similar companies. The strongest pattern is clear: companies are not hiring \u201cprompt engineers\u201d; they are hiring people who can enter a messy customer environment, understand the real business problem, build working software, integrate with existing systems, deploy securely, measure value, and feed reusable patterns back into product\/engineering<\/strong>. Palantir describes FDSEs as engineers who work directly with customers to understand major problems and implement data-driven solutions. OpenAI emphasizes custom scalable software using OpenAI APIs and collaboration across customers, sales, product, research, and engineering. Anthropic expects production apps with Claude, MCP servers, sub-agents, agent skills, deployment support, and repeatable patterns. Together AI stresses inference optimization, fine-tuning, vLLM\/TensorRT-LLM\/SGLang, KV cache, quantization, and post-training. Okta\u2019s AI-agent FDE role adds identity, OAuth\/OIDC, fine-grained authorization, audit trails, kill switches, OWASP Agentic risks, NIST AI RMF, MITRE ATLAS, and regulated deployment thinking. Vercel adds TypeScript, Next.js, production agents, MCP servers, and enterprise migration ability. PayPay\u2019s FDE role strongly validates the \u201cdeep dive \u2192 identify real workflow pain \u2192 PoC \u2192 requirement bridge \u2192 production rollout \u2192 adoption\u201d model. (Lever<\/a>)<\/p>\n\n\n\n

Discuss with us<\/h2>\n\n\n\n

email – contact@devopsschool.com<\/p>\n\n\n\n

Scan the code<\/figcaption><\/a><\/figure>\n
Open Chat<\/a><\/div>\n<\/div>\n\n\n\n

Program Positioning<\/h2>\n\n\n\n

Audience:<\/strong> 12\u201318 years experienced engineers, architects, DevOps\/SRE leads, platform engineers, data engineers, AI engineers, solution architects, technical consultants.<\/p>\n\n\n\n

Goal:<\/strong> Build engineers who can handle real enterprise AI\/software deployments from zero ambiguity to production adoption.<\/p>\n\n\n\n

Daily Format:<\/strong>
First 2 hours:<\/strong> Discussion, architecture walkthrough, demo, case study.
Next 2 hours:<\/strong> Assignment, lab, project implementation, field simulation.<\/p>\n\n\n\n

Core Skill Pillars<\/h2>\n\n\n\n
Pillar<\/th>What participants must master<\/th><\/tr><\/thead>
FDE Mindset<\/td>Customer discovery, ambiguity handling, business-value mapping, fast prototyping, ownership<\/td><\/tr>
Software Engineering<\/td>Python, TypeScript, APIs, backend systems, frontend basics, testing, code quality<\/td><\/tr>
Enterprise Architecture<\/td>Cloud, Kubernetes, CI\/CD, security, integration, scalability, observability<\/td><\/tr>
Data Engineering<\/td>SQL, ETL\/ELT, lakehouse, warehouses, pipelines, data quality, governance<\/td><\/tr>
Applied AI<\/td>LLM APIs, RAG, agents, tool use, MCP, prompt engineering, evals, guardrails<\/td><\/tr>
Production AI<\/td>Inference, cost, latency, caching, fine-tuning, LoRA, model selection, deployment<\/td><\/tr>
Security & Compliance<\/td>OAuth\/OIDC, RBAC\/ABAC\/ReBAC, secrets, PII, audit logs, AI security, policy engines<\/td><\/tr>
Customer Delivery<\/td>Workshops, stakeholder management, demos, requirements, documentation, adoption<\/td><\/tr>
Product Feedback Loop<\/td>Reusable patterns, internal accelerators, reference architectures, product insights<\/td><\/tr>
Capstone<\/td>End-to-end customer problem \u2192 production-grade AI\/software solution<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n

42-Day Detailed Training Agenda<\/h1>\n\n\n\n
Day<\/th>Theme<\/th>2 Hours Discussion \/ Demo<\/th>2 Hours Lab \/ Assignment<\/th><\/tr><\/thead>
1<\/strong><\/td>FDE Role, Market & Mindset<\/td>What is a Forward Deployed Engineer? Difference between FDE, solution architect, consultant, SRE, product engineer, AI engineer. Study Palantir\/OpenAI\/Anthropic-style expectations.<\/td>Write a personal FDE readiness assessment. Map current skills to FDE skill pillars. Create individual learning backlog.<\/td><\/tr>
2<\/strong><\/td>Customer Discovery & Problem Framing<\/td>How to enter a customer environment, ask the right questions, avoid solution bias, identify business pain, map stakeholders, define success metrics.<\/td>Simulated customer interview. Create discovery notes, problem statement, stakeholders map, success metrics, risks.<\/td><\/tr>
3<\/strong><\/td>From Ambiguity to Architecture<\/td>Turning vague business problems into architecture. User journey, workflow mapping, domain model, system boundary, non-functional requirements.<\/td>Convert a messy business case into architecture canvas: actors, systems, data, APIs, constraints, SLA, security needs.<\/td><\/tr>
4<\/strong><\/td>FDE Communication & Executive Storytelling<\/td>How to explain technical ideas to CTO, CISO, business head, product manager, and engineers differently. Demo structure: problem \u2192 solution \u2192 impact.<\/td>Prepare a 5-minute executive pitch and a 10-minute technical explanation for the same solution.<\/td><\/tr>
5<\/strong><\/td>Product Thinking for Engineers<\/td>MVP vs PoC vs pilot vs production. Feature prioritization, adoption risk, user feedback, product telemetry, roadmap thinking.<\/td>Create MVP scope for a customer AI assistant. Define v1, v2, rejected features, adoption plan.<\/td><\/tr>
6<\/strong><\/td>Production Software Foundations<\/td>Modern backend architecture: REST, GraphQL, event-driven APIs, service boundaries, idempotency, pagination, retries, rate limits.<\/td>Build a small FastAPI service with REST endpoints, validation, error handling, logging, and tests.<\/td><\/tr>
7<\/strong><\/td>TypeScript & Frontend for FDEs<\/td>Why FDEs need enough frontend skill. TypeScript, React\/Next.js, internal tools, dashboards, admin UIs, customer demos.<\/td>Build a minimal Next.js dashboard consuming the FastAPI service.<\/td><\/tr>
8<\/strong><\/td>Git, Code Review & AI-Native Development<\/td>Git workflow, trunk-based development, PR quality, AI coding assistants, code review discipline, safe AI-generated code usage.<\/td>Create a repo with backend + frontend. Use AI-assisted development, then manually review and fix generated code.<\/td><\/tr>
9<\/strong><\/td>Cloud Architecture for FDEs<\/td>AWS\/GCP\/Azure fundamentals for customer deployments. VPC, IAM, compute, storage, databases, managed AI services.<\/td>Design cloud architecture for a customer-facing AI application with network, compute, DB, object storage, and IAM.<\/td><\/tr>
10<\/strong><\/td>Containers & Docker<\/td>Dockerfile best practices, multi-stage builds, local dev containers, image security, registry workflows.<\/td>Containerize backend and frontend. Add docker-compose with API, UI, Postgres, Redis.<\/td><\/tr>
11<\/strong><\/td>Kubernetes for Deployed Engineers<\/td>Kubernetes concepts: Pods, Deployments, Services, Ingress, ConfigMaps, Secrets, HPA, Jobs, CronJobs.<\/td>Deploy the application to local Kubernetes using kind\/minikube. Add ingress and environment configs.<\/td><\/tr>
12<\/strong><\/td>CI\/CD & Release Engineering<\/td>GitHub Actions\/GitLab CI, build\/test\/deploy pipelines, environment promotion, rollback strategy, feature flags.<\/td>Build CI pipeline: lint, test, Docker build, security scan, deploy to dev namespace.<\/td><\/tr>
13<\/strong><\/td>Infrastructure as Code<\/td>Terraform fundamentals, modules, remote state, environments, drift, secrets, policy checks.<\/td>Create Terraform skeleton for cloud deployment: network, database, container runtime, secrets.<\/td><\/tr>
14<\/strong><\/td>Observability & SRE Basics<\/td>Logs, metrics, traces, SLIs\/SLOs, OpenTelemetry, Prometheus, Grafana, incident response, runbooks.<\/td>Instrument API with structured logs, metrics, traces. Build a basic dashboard and alert rule.<\/td><\/tr>
15<\/strong><\/td>Enterprise Integration Patterns<\/td>Connecting to customer systems: CRM, ERP, ticketing, Slack, email, databases, SaaS APIs. Webhooks, queues, batch sync.<\/td>Integrate app with one mock enterprise system and Slack\/webhook notification flow.<\/td><\/tr>
16<\/strong><\/td>SQL, Data Modeling & Analytics<\/td>SQL refresher for senior engineers, transactional vs analytical models, indexing, query tuning, data contracts.<\/td>Design schema for customer support\/case-management domain. Write analytical queries and optimize slow query.<\/td><\/tr>
17<\/strong><\/td>Data Pipelines & ELT<\/td>ETL\/ELT, Airflow\/Dagster, dbt, lakehouse concepts, batch vs streaming, data quality checks.<\/td>Build a mini pipeline: ingest CSV\/API data \u2192 transform \u2192 validate \u2192 load into analytical table.<\/td><\/tr>
18<\/strong><\/td>Streaming & Event-Driven Systems<\/td>Kafka\/Pub\/Sub\/Kinesis concepts, event schemas, consumers, retry\/DLQ, ordering, exactly-once myths.<\/td>Build event flow for customer actions. Add producer, consumer, retry, DLQ simulation.<\/td><\/tr>
19<\/strong><\/td>Enterprise Search & Knowledge Systems<\/td>Document ingestion, chunking, metadata, ACL-aware search, enterprise graph idea, connectors. Glean-like use cases.<\/td>Build document ingestion pipeline with metadata, access tags, and search API.<\/td><\/tr>
20<\/strong><\/td>LLM Foundations for FDEs<\/td>LLM capabilities\/limits, tokens, context windows, temperature, model selection, structured output, hallucinations.<\/td>Build an LLM API wrapper supporting multiple providers and structured JSON response validation.<\/td><\/tr>
21<\/strong><\/td>Prompt Engineering for Production<\/td>System prompts, few-shot, chain-of-thought alternatives, tool instructions, prompt versioning, prompt injection risks.<\/td>Create prompt templates for classification, extraction, summarization, and customer-support reply generation.<\/td><\/tr>
22<\/strong><\/td>RAG Architecture<\/td>RAG pipeline: loaders, chunking, embeddings, vector DB, hybrid search, reranking, citations, grounding, freshness.<\/td>Build RAG over uploaded enterprise documents using pgvector\/Qdrant\/Chroma and return cited answers.<\/td><\/tr>
23<\/strong><\/td>Advanced RAG<\/td>Query rewriting, multi-query retrieval, metadata filtering, ACL filtering, rerankers, evaluation datasets, anti-hallucination design.<\/td>Improve previous RAG system with hybrid search, reranking, confidence scoring, and \u201cI don\u2019t know\u201d behavior.<\/td><\/tr>
24<\/strong><\/td>Agents & Tool Use<\/td>Agent patterns, tools\/functions, planning, reflection limits, human-in-the-loop, safe tool execution.<\/td>Build an agent that can search docs, query database, create ticket draft, and ask for approval before action.<\/td><\/tr>
25<\/strong><\/td>MCP, Agent Skills & Enterprise Tooling<\/td>MCP concepts, MCP server design, agent skills, tool schemas, secure tool exposure, local vs remote tools. Anthropic and Vercel-style FDE roles now explicitly mention MCP\/agent skills. (Greenhouse<\/a>)<\/td>Build a simple MCP server exposing customer-data lookup and ticket-update tools. Connect it to an agent client.<\/td><\/tr>
26<\/strong><\/td>Multi-Agent & Workflow Automation<\/td>LangGraph-style workflows, deterministic vs agentic steps, state machines, approvals, retries, audit trail.<\/td>Build an agentic workflow: classify request \u2192 retrieve context \u2192 draft action \u2192 validate \u2192 human approval \u2192 execute.<\/td><\/tr>
27<\/strong><\/td>LLM Evaluation & Quality Gates<\/td>Offline evals, golden datasets, RAGAS\/DeepEval\/promptfoo, correctness, faithfulness, toxicity, latency, cost, regression testing.<\/td>Create eval dataset and run automated tests for RAG\/agent quality. Add eval gate to CI.<\/td><\/tr>
28<\/strong><\/td>AI Observability & Cost Control<\/td>Token usage, latency, trace spans, prompt\/version tracking, cost-per-request, cache hit rate, user feedback.<\/td>Add Langfuse\/Phoenix-style tracing, token\/cost dashboard, and feedback collection to the AI app.<\/td><\/tr>
29<\/strong><\/td>Model Selection & Inference Strategy<\/td>OpenAI\/Claude\/Gemini\/Bedrock\/Vertex\/Databricks\/open-source model tradeoffs. Latency, cost, accuracy, data residency.<\/td>Create a model-selection matrix for 5 customer scenarios: support, legal, coding, analytics, document processing.<\/td><\/tr>
30<\/strong><\/td>Open-Source LLM Deployment<\/td>vLLM, SGLang, TensorRT-LLM, Ollama, GPU basics, batching, KV cache, quantization. Together AI roles emphasize inference depth and optimization. (Greenhouse<\/a>)<\/td>Deploy an open-source model locally or on GPU runtime. Benchmark latency, throughput, memory, and cost assumptions.<\/td><\/tr>
31<\/strong><\/td>Fine-Tuning & Post-Training<\/td>SFT, LoRA, DPO, RLHF\/GRPO concepts, when not to fine-tune, dataset preparation, evaluation before\/after.<\/td>Prepare a small fine-tuning dataset. Run LoRA\/SFT demo or simulated fine-tuning pipeline with evaluation report.<\/td><\/tr>
32<\/strong><\/td>Security for Enterprise AI<\/td>Threat model: prompt injection, data leakage, insecure tools, over-permissioned agents, secrets exposure, supply chain.<\/td>Red-team the agent. Add input\/output filters, tool allowlist, approval gates, and security test cases.<\/td><\/tr>
33<\/strong><\/td>Identity, AuthZ & Governance<\/td>OAuth2, OIDC, SAML, SCIM, RBAC, ABAC, ReBAC, OPA\/OpenFGA\/Cedar, audit logs, kill switch. Okta highlights these as core agent-identity patterns. (Okta<\/a>)<\/td>Add authentication, role-based access, audit logs, and admin kill-switch to the AI workflow.<\/td><\/tr>
34<\/strong><\/td>Compliance, Privacy & Responsible AI<\/td>PII handling, data retention, SOC 2, HIPAA-style thinking, FedRAMP-style thinking, EU AI Act awareness, NIST AI RMF, MITRE ATLAS.<\/td>Create AI risk register, data-flow diagram, privacy controls, and responsible AI checklist for the capstone.<\/td><\/tr>
35<\/strong><\/td>Customer Environment Deep Dive<\/td>How to perform codebase audit, architecture review, data review, security review, workflow observation, and deployment readiness.<\/td>Given a messy sample system, produce assessment report: current state, gaps, risks, quick wins, roadmap.<\/td><\/tr>
36<\/strong><\/td>Solution Design Workshop Simulation<\/td>Running a customer workshop: agenda, whiteboarding, tradeoff decisions, documenting assumptions, closing action items.<\/td>Teams run a simulated workshop and produce solution design doc plus decision log.<\/td><\/tr>
37<\/strong><\/td>Production Rollout & Change Management<\/td>Pilot design, rollout phases, adoption metrics, training users, rollback, support model, ownership handover.<\/td>Create rollout plan for capstone: pilot users, acceptance criteria, support model, training plan, rollback.<\/td><\/tr>
38<\/strong><\/td>Commercial & Delivery Discipline<\/td>Estimation, scope control, risk management, dependency tracking, weekly status reports, steering committee updates.<\/td>Prepare delivery plan: timeline, RACI, RAID log, milestone tracker, weekly customer status update.<\/td><\/tr>
39<\/strong><\/td>Building Reusable FDE Accelerators<\/td>Templates, starter kits, reference architectures, reusable connectors, internal knowledge base, product feedback loop.<\/td>Package reusable components from labs into an \u201cFDE accelerator kit\u201d: repo template, docs, diagrams, scripts.<\/td><\/tr>
40<\/strong><\/td>Capstone Build Day 1<\/td>Capstone architecture review. Teams choose one domain: customer support agent, enterprise knowledge agent, sales intelligence agent, compliance review agent, DevOps incident agent, data analytics agent.<\/td>Build capstone v1: backend, frontend, RAG, agent workflow, auth, logging, basic deployment.<\/td><\/tr>
41<\/strong><\/td>Capstone Build Day 2<\/td>Production-hardening clinic: security, evals, observability, cost, performance, documentation, demo storytelling.<\/td>Complete capstone: CI\/CD, monitoring, evals, risk controls, deployment guide, user guide, executive deck.<\/td><\/tr>
42<\/strong><\/td>Final Demo, Assessment & FDE Playbook<\/td>Final customer-style demo: business problem, live solution, architecture, security, cost, rollout, roadmap. Instructor review against FDE rubric.<\/td>Final assessment, feedback, individual growth plan, reusable FDE playbook submission. Optional 2h buffer can be excluded to align with 166h contract.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n

Capstone Project Options<\/h1>\n\n\n\n

Each team should choose one. All should be built as production-style<\/strong>, not demo-only.<\/p>\n\n\n\n

Capstone<\/th>Description<\/th><\/tr><\/thead>
Enterprise Knowledge Agent<\/strong><\/td>RAG + ACL-aware document search + Slack\/Teams interface + citations + audit logs<\/td><\/tr>
Customer Support Resolution Agent<\/strong><\/td>Ticket classification, retrieval, suggested response, CRM\/ticketing integration, human approval<\/td><\/tr>
DevOps Incident Agent<\/strong><\/td>Pull logs\/metrics, summarize incident, suggest remediation, create Jira ticket, generate postmortem<\/td><\/tr>
Compliance Review Agent<\/strong><\/td>Analyze policies\/contracts, identify risks, produce review notes with evidence and approval workflow<\/td><\/tr>
Sales\/Account Intelligence Agent<\/strong><\/td>Aggregate CRM, emails, docs, product usage, generate account brief and next-best action<\/td><\/tr>
Data Analytics Agent<\/strong><\/td>Natural-language-to-SQL with safe query guardrails, result explanation, dashboard generation<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n

Mandatory Tools \/ Platforms to Cover<\/h1>\n\n\n\n
Area<\/th>Tools \/ Platforms<\/th><\/tr><\/thead>
Languages<\/td>Python, TypeScript, SQL<\/td><\/tr>
Backend<\/td>FastAPI, Node.js\/NestJS optional<\/td><\/tr>
Frontend<\/td>React, Next.js<\/td><\/tr>
Data<\/td>PostgreSQL, pgvector, Redis, Kafka\/PubSub basics, dbt, Airflow\/Dagster<\/td><\/tr>
AI\/LLM<\/td>OpenAI API, Anthropic Claude API, Gemini\/Vertex AI, AWS Bedrock, Hugging Face<\/td><\/tr>
RAG<\/td>LlamaIndex, LangChain, vector DB: pgvector\/Qdrant\/Chroma; optional Pinecone\/Weaviate<\/td><\/tr>
Agents<\/td>LangGraph, tool\/function calling, MCP server\/client, workflow orchestration<\/td><\/tr>
Inference<\/td>Ollama, vLLM, SGLang, TensorRT-LLM concepts<\/td><\/tr>
Fine-tuning<\/td>Hugging Face, LoRA\/QLoRA, PEFT concepts, MLflow optional<\/td><\/tr>
DevOps<\/td>Docker, Kubernetes, Helm, Terraform, GitHub Actions<\/td><\/tr>
Observability<\/td>OpenTelemetry, Prometheus, Grafana, Langfuse\/Phoenix, structured logging<\/td><\/tr>
Security<\/td>OAuth2, OIDC, JWT, Vault\/SOPS, OPA, OpenFGA\/Cedar concepts<\/td><\/tr>
Governance<\/td>PII masking, audit logs, policy-as-code, risk register, approval workflows<\/td><\/tr>
Collaboration<\/td>Jira, Confluence, Slack, architecture decision records, customer status reports<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n

Final Assessment Rubric<\/h1>\n\n\n\n
Area<\/th>Weight<\/th><\/tr><\/thead>
Customer problem understanding<\/td>15%<\/td><\/tr>
Architecture quality<\/td>15%<\/td><\/tr>
Working software quality<\/td>20%<\/td><\/tr>
AI\/RAG\/agent correctness<\/td>15%<\/td><\/tr>
Security, privacy, governance<\/td>10%<\/td><\/tr>
Observability, cost, reliability<\/td>10%<\/td><\/tr>
Demo\/storytelling\/customer communication<\/td>10%<\/td><\/tr>
Documentation and handover<\/td>5%<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n

What Makes This Agenda \u201cFDE-Level\u201d<\/h1>\n\n\n\n

This agenda intentionally avoids becoming only a GenAI course<\/strong>, only a DevOps course<\/strong>, or only a solution architect course<\/strong>. The strongest FDEs are judged by whether they can:<\/p>\n\n\n\n

    \n
  1. Walk into a customer environment with incomplete information.<\/li>\n\n\n\n
  2. Find the real problem behind the stated problem.<\/li>\n\n\n\n
  3. Build a working solution fast.<\/li>\n\n\n\n
  4. Integrate it with existing systems.<\/li>\n\n\n\n
  5. Secure it for enterprise use.<\/li>\n\n\n\n
  6. Deploy and monitor it.<\/li>\n\n\n\n
  7. Prove business value.<\/li>\n\n\n\n
  8. Teach the customer team to own it.<\/li>\n\n\n\n
  9. Convert repeated field learnings into reusable product patterns.<\/li>\n<\/ol>\n\n\n\n

    <\/p>\n","protected":false},"excerpt":{"rendered":"

    I studied current FDE-style roles from Palantir, OpenAI, Anthropic, Google Cloud, Databricks, Together AI, Okta, Vercel, PayPay, Glean, Scale AI and similar companies. The strongest pattern is… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_joinchat":[],"footnotes":""},"categories":[11138],"tags":[],"class_list":["post-76990","post","type-post","status-publish","format-standard","hentry","category-best-tools"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/76990","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=76990"}],"version-history":[{"count":2,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/76990\/revisions"}],"predecessor-version":[{"id":76992,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/76990\/revisions\/76992"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=76990"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=76990"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=76990"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}