Forward Deployed Engineering: o próximo passo para desenvolvedores PHP?

Durante muito tempo, a carreira de um desenvolvedor foi apresentada de uma maneira relativamente previsível:

aprender uma linguagem → aprender um framework → trabalhar com APIs → conhecer bancos de dados → evoluir para arquitetura.

Mas o mercado de software está mudando.

Com ferramentas de IA capazes de gerar código, criar testes, analisar repositórios, consumir APIs e até executar tarefas completas, escrever código continua sendo importante, mas está deixando de ser a única parte difícil do desenvolvimento.

Cada vez mais, o diferencial está em outra capacidade:

entender um problema real, descobrir como resolvê-lo e conseguir colocar a solução funcionando no ambiente do cliente.

É nesse contexto que aparece um perfil que vem ganhando espaço: Forward Deployed Engineer (FDE).

O que é Forward Deployed Engineering?

Forward Deployed Engineering pode ser traduzido livremente como Engenharia de Software Implantada no Cliente.

A ideia é colocar engenheiros muito próximos dos problemas reais de uma empresa.

Em vez de receber apenas uma especificação como:

"Crie uma API para cadastrar pedidos."

o FDE pode participar de toda a descoberta:

• Como o pedido é criado atualmente?
• Quem utiliza esse processo?
• Quais sistemas estão envolvidos?
• Onde estão os dados?
• Existe um ERP?
• Existe um CRM?
• Existem sistemas legados?
• Existe uma API?
• Quais etapas são manuais?
• O que pode ser automatizado?
• Onde uma IA pode ajudar?
• Quais riscos existem?
• Como saberemos se a solução realmente funcionou?

Depois disso, o engenheiro participa da implementação.

Ou seja, o FDE não fica limitado a uma camada específica do sistema.

Ele pode trabalhar com:

problema → arquitetura → código → integração → infraestrutura → IA → implantação → feedback → melhoria

FDE não é simplesmente "um desenvolvedor que trabalha no cliente"

Essa diferença é importante.

Um desenvolvedor tradicional pode receber uma tarefa bastante bem definida:

"Criar endpoint para consultar pedidos."

O FDE pode receber algo muito mais aberto:

"Nossa equipe demora horas para processar esses pedidos. Queremos automatizar isso."

A segunda situação exige muito mais do que programação.

É necessário descobrir o que realmente está acontecendo.

Talvez a solução seja uma API.

Talvez seja uma fila.

Talvez seja uma integração com o ERP.

Talvez seja uma automação.

Talvez seja um agente de IA.

Talvez seja simplesmente melhorar um processo que não deveria existir daquela maneira.

E talvez a melhor solução seja uma combinação de tudo isso.

Por que esse perfil está ganhando importância com IA?

A IA mudou bastante a velocidade com que software pode ser produzido.

Hoje podemos utilizar modelos para:

• gerar código;
• explicar código legado;
• criar testes;
• encontrar bugs;
• escrever documentação;
• analisar logs;
• criar queries;
• trabalhar com APIs;
• criar protótipos;
• refatorar código;
• pesquisar documentação;
• operar ferramentas;
• executar determinadas tarefas em ambientes controlados.

Mas existe um problema:

gerar código não significa resolver um problema de negócio.

Uma IA pode gerar rapidamente uma API tecnicamente correta.

Isso não significa que essa API deveria existir.

O papel do engenheiro começa cada vez mais antes do código.

O FDE precisa entender o negócio

Essa talvez seja uma das maiores mudanças de mentalidade.

Um bom FDE não pensa apenas:

"Como vou implementar isso?"

Ele também pergunta:

"Por que estamos implementando isso?"

E:

"Como saberemos que isso resolveu o problema?"

Imagine uma empresa que possui uma equipe responsável por analisar centenas de documentos diariamente.

Uma abordagem tradicional poderia ser:

"Vamos criar uma aplicação para fazer upload dos documentos."

Um FDE investigaria mais profundamente:

1. De onde vêm os documentos?
2. Quem os recebe?
3. Qual formato possuem?
4. O que precisa ser extraído?
5. Onde essas informações são armazenadas?
6. Quem precisa delas?
7. Existem regras de negócio?
8. Quais decisões podem ser automatizadas?
9. Quais precisam de aprovação humana?
10. Como medir erros?
11. O que acontece quando a IA não tiver certeza?

Depois dessa investigação, a solução poderia envolver:

Documento
   ↓
Storage
   ↓
Processamento
   ↓
LLM
   ↓
Validação
   ↓
Sistema interno
   ↓
Aprovação humana

O código é apenas uma parte da solução.

E onde entra o PHP?

Aqui está uma parte interessante para quem trabalha com PHP.

O crescimento de IA não significa que PHP deixou de ser relevante.

Pelo contrário.

Grande parte dos problemas que precisam ser resolvidos no mundo real envolve:

• APIs;
• bancos de dados;
• autenticação;
• sistemas administrativos;
• CMS;
• integrações;
• filas;
• webhooks;
• sistemas legados;
• processamento de dados;
• aplicações web.

Tudo isso continua sendo terreno conhecido do desenvolvedor PHP.

Além disso, já existe um SDK oficial de PHP para o Model Context Protocol (MCP), permitindo construir servidores e clientes MCP em PHP. O SDK permite expor ferramentas, recursos e prompts para hosts compatíveis com MCP e suporta transportes como STDIO e Streamable HTTP.

Isso abre uma possibilidade interessante:

um desenvolvedor PHP pode continuar usando PHP como camada de negócio e integração enquanto adiciona capacidades de IA aos sistemas existentes.

O desenvolvedor PHP precisa virar especialista em IA?

Não necessariamente.

Esse é um erro comum.

Você não precisa começar treinando modelos de linguagem do zero.

Para atuar próximo desse tipo de trabalho, é mais importante entender como utilizar modelos existentes dentro de sistemas reais.

Comece entendendo conceitos como:

• LLMs;
• tokens;
• contexto;
• embeddings;
• RAG;
• function calling;
• tool use;
• agentes;
• MCP;
• structured outputs;
• streaming;
• avaliação de respostas;
• observabilidade;
• guardrails;
• custo e latência.

O objetivo não é virar pesquisador de machine learning.

É conseguir responder:

"Onde uma IA faz sentido dentro deste sistema?"

Aprenda a construir ferramentas para agentes

Um dos conceitos mais importantes é tool use.

Um modelo pode receber ferramentas que permitem consultar dados ou executar ações.

Por exemplo:

Agente
  │
  ├── consultar_cliente()
  ├── consultar_pedido()
  ├── criar_ticket()
  ├── enviar_email()
  └── atualizar_crm()

A IA decide quando utilizar uma ferramenta de acordo com as instruções e o contexto.

A documentação atual da OpenAI trata ferramentas como uma parte central dos agentes e separa, entre outros conceitos, ferramentas de dados, ações e orquestração.

Para um desenvolvedor PHP, isso é particularmente interessante porque essas ferramentas podem ser implementadas sobre aquilo que já conhecemos:

PHP
  ↓
Service
  ↓
API / Banco / Sistema externo
  ↓
Tool
  ↓
Agente

Você não precisa abandonar sua experiência anterior.

Você pode transformá-la em ferramentas que agentes conseguem utilizar.

MCP: uma tecnologia que vale estudar

Outro assunto importante é o Model Context Protocol (MCP).

O MCP cria uma forma padronizada de conectar aplicações de IA a ferramentas e fontes de contexto.

O SDK oficial de PHP permite criar servidores MCP que expõem:

• Tools;
• Resources;
• Prompts.

Por exemplo, imagine um sistema de e-commerce em PHP.

Você poderia criar ferramentas como:

buscar_cliente
buscar_pedido
consultar_estoque
calcular_frete
criar_ticket

Um agente poderia utilizar essas ferramentas dentro de um fluxo controlado.

Para quem já trabalha com APIs e sistemas backend, a ideia é relativamente natural.

O FDE precisa dominar APIs

Aqui o desenvolvedor PHP já começa com uma vantagem.

REST continua sendo extremamente importante.

Mas não basta saber criar:

GET /users
POST /orders
PUT /customers/123

É importante entender também:

• autenticação;
• OAuth;
• JWT;
• webhooks;
• rate limits;
• retries;
• idempotência;
• paginação;
• versionamento;
• tratamento de erros;
• timeouts;
• observabilidade.

Um FDE frequentemente precisa integrar sistemas que não foram projetados para conversar entre si.

É comum encontrar algo como:

Drupal
   ↓
API
   ↓
ERP
   ↓
CRM
   ↓
Data Warehouse
   ↓
Agente de IA

E alguém precisa fazer tudo isso funcionar.

Sistemas legados são uma oportunidade

Outro ponto importante:

não tenha medo de sistemas legados.

Um FDE frequentemente encontrará sistemas antigos.

PHP 7.

Drupal antigo.

APIs sem documentação.

Banco MySQL com tabelas misteriosas.

Aplicação monolítica.

Scripts executados via cron.

Integrações feitas há dez anos.

E documentação inexistente.

Isso pode parecer ruim para quem pensa apenas em tecnologias modernas.

Mas é justamente aí que experiência prática se torna valiosa.

A empresa não precisa necessariamente substituir tudo.

Talvez seja possível colocar uma nova camada em cima:

              ┌───────────────┐
              │   Agente IA   │
              └───────┬───────┘
                      │
                ┌─────▼─────┐
                │ API / MCP │
                └─────┬─────┘
                      │
          ┌───────────▼───────────┐
          │     Sistema legado   │
          └───────────────────────┘

Esse tipo de integração é exatamente o tipo de problema em que conhecimento de backend pode fazer diferença.

O FDE precisa saber conversar com pessoas

Essa talvez seja uma das habilidades mais subestimadas.

Você pode ser excelente em PHP.

Mas se não consegue conversar com o usuário para descobrir o problema, seu código pode resolver a coisa errada.

O FDE precisa desenvolver habilidades como:

Fazer perguntas

Não aceitar imediatamente a primeira solução sugerida.

Escutar

Entender como a equipe realmente trabalha.

Traduzir

Transformar:

"Nosso processo é uma bagunça."

em requisitos técnicos.

Explicar

Conseguir explicar uma arquitetura complexa para alguém que não é desenvolvedor.

Negociar

Definir o que entra na primeira versão e o que pode esperar.

Demonstrar

Mostrar rapidamente algo funcionando e coletar feedback.

Aprenda a construir POCs rapidamente

Uma habilidade muito importante é conseguir transformar uma ideia em uma prova de conceito.

Não precisa ser código perfeito.

Uma POC pode responder:

"Isso é tecnicamente possível?"

Por exemplo:

Problema:
Classificar solicitações recebidas por email.

POC:

Email
 ↓
LLM
 ↓
Classificação
 ↓
JSON estruturado
 ↓
PHP
 ↓
Sistema interno

Se funcionar, aí começa o trabalho de engenharia:

• segurança;
• testes;
• observabilidade;
• tratamento de erros;
• performance;
• custos;
• permissões;
• deploy;
• monitoramento.

Essa separação entre experimentar rapidamente e construir para produção é muito importante.

Mas cuidado com o "vibe coding"

Ferramentas de IA permitem produzir muito código rapidamente.

Isso é excelente para prototipação.

Mas um FDE não pode simplesmente aceitar tudo que a IA produz.

Você precisa continuar entendendo:

• arquitetura;
• segurança;
• banco de dados;
• concorrência;
• performance;
• testes;
• autenticação;
• autorização;
• infraestrutura.

A IA pode escrever o código.

A responsabilidade pela solução continua sendo do engenheiro.

Use IA como multiplicador

Em vez de pensar:

"A IA vai programar por mim."

Pense:

"Como posso usar IA para aumentar minha capacidade de resolver problemas?"

Alguns exemplos:

Antes de programar

Peça para a IA:

• analisar o problema;
• levantar perguntas;
• analisar documentação;
• sugerir riscos;
• comparar arquiteturas.

Durante o desenvolvimento

Use IA para:

• gerar código;
• criar testes;
• explicar código legado;
• refatorar;
• criar documentação;
• investigar erros.

Depois

Use IA para:

• revisar mudanças;
• analisar logs;
• sugerir testes;
• revisar documentação;
• procurar casos extremos.

O desenvolvedor deixa de ser apenas um executor de código e passa a ser cada vez mais um orquestrador de ferramentas e conhecimento.

Ferramentas que vale conhecer

Não é necessário aprender todas.

O objetivo é conhecer categorias diferentes.

Desenvolvimento assistido por IA

Explore ferramentas como:

• ChatGPT;
• Claude;
• GitHub Copilot;
• Codex;
• Claude Code;
• OpenCode.

O importante é aprender a trabalhar com agentes de programação, não apenas com autocomplete.

APIs de IA

Conheça pelo menos uma plataforma profundamente.

Por exemplo:

• OpenAI API;
• Anthropic API;
• Google Gemini API;
• modelos open source.

Aprenda conceitos que se repetem entre provedores.

Agents

Estude:

• Agents SDK;
• tool calling;
• handoffs;
• workflows;
• guardrails;
• tracing;
• avaliação.

A arquitetura moderna de agentes normalmente combina modelo + instruções + ferramentas + controles.

Ferramentas de agentes também estão incorporando tracing e observabilidade para permitir investigar o que o agente fez, quais ferramentas chamou e quanto tempo cada etapa levou.

MCP

Aprenda:

• criar um MCP Server;
• criar tools;
• resources;
• prompts;
• conectar clientes;
• autenticação;
• HTTP/STDIO.

E, principalmente:

tente fazer isso usando PHP.

Existe um SDK oficial de MCP para PHP, atualmente em desenvolvimento experimental, que requer PHP 8.1+ e pode ser instalado via Composer.

E para quem trabalha com Drupal?

Aqui existe uma oportunidade ainda mais interessante.

Drupal já funciona como uma excelente plataforma para:

• conteúdo;
• usuários;
• permissões;
• workflows;
• APIs;
• entidades;
• integrações.

Imagine um Drupal fornecendo dados e ações para um agente:

              ┌──────────────┐
              │   AI Agent   │
              └──────┬───────┘
                     │
              ┌──────▼───────┐
              │ MCP / Tools  │
              └──────┬───────┘
                     │
              ┌──────▼───────┐
              │    Drupal    │
              └──────┬───────┘
                     │
       ┌─────────────┼─────────────┐
       ↓             ↓             ↓
    Content       Users        Workflows

Isso pode permitir aplicações como:

• assistente editorial;
• pesquisa interna;
• análise de conteúdo;
• automação de publicação;
• suporte aos editores;
• consulta de informações;
• integração com sistemas externos.

Para quem já domina Drupal, estudar IA não precisa significar abandonar Drupal.

Pode significar adicionar uma nova camada de inteligência aos sistemas que você já sabe construir.

O que estudar para se preparar?

Uma possível trilha para um desenvolvedor PHP seria:

Nível 1 — Fortalecer backend

Revise:

• PHP moderno;
• Composer;
• Symfony;
• APIs REST;
• SQL;
• PostgreSQL/MySQL;
• Docker;
• Git;
• Linux;
• testes automatizados.

Nível 2 — Integrações

Estude:

• REST;
• GraphQL;
• OAuth;
• JWT;
• Webhooks;
• filas;
• Redis;
• mensageria;
• APIs de terceiros.

Nível 3 — Cloud e infraestrutura

Não precisa virar DevOps, mas entenda:

• containers;
• CI/CD;
• DNS;
• CDN;
• storage;
• logs;
• monitoring;
• secrets;
• IAM;
• cloud providers.

Nível 4 — IA aplicada

Depois entre em:

• LLM APIs;
• prompting;
• structured outputs;
• embeddings;
• RAG;
• function calling;
• tool use;
• agentes;
• avaliação;
• guardrails.

Nível 5 — MCP

Construa:

um MCP Server em PHP.

Depois faça um cliente consumir esse servidor.

Isso força você a entender como aplicações tradicionais podem conversar com sistemas de IA.

Nível 6 — Projetos reais

Aqui está a parte mais importante.

Não fique apenas fazendo:

"Chatbot com IA."

Construa algo que resolva um problema.

Por exemplo:

Projeto 1 — Agente para documentação

Um agente que pesquisa a documentação de uma aplicação PHP e responde perguntas.

Projeto 2 — Agente para GitHub

Um agente que analisa issues, consulta o código e sugere uma solução.

Projeto 3 — Agente para Drupal

Um agente que consulta conteúdos e informações do Drupal.

Projeto 4 — MCP para PHP

Crie um MCP Server que expõe:

listar_usuarios
buscar_usuario
buscar_pedido
consultar_produto

Projeto 5 — Sistema completo

Construa:

Drupal / Symfony
        ↓
       API
        ↓
      MCP
        ↓
    AI Agent
        ↓
   Ferramentas
        ↓
 Sistemas externos

Isso começa a parecer muito mais com um problema real de empresa.

O perfil profissional começa a mudar

Talvez uma das maiores mudanças seja esta:

Antes

Requisito
   ↓
Código
   ↓
Deploy

Agora

Problema
   ↓
Descoberta
   ↓
Arquitetura
   ↓
POC
   ↓
IA + Código + Integrações
   ↓
Validação
   ↓
Produção
   ↓
Observabilidade
   ↓
Iteração

O desenvolvedor precisa participar de mais etapas.

As habilidades que podem diferenciar um FDE

Podemos resumir em algumas áreas:

Engenharia

• PHP;
• APIs;
• bancos;
• arquitetura;
• testes;
• cloud;
• segurança.

IA

• LLMs;
• agentes;
• tools;
• MCP;
• RAG;
• avaliação;
• observabilidade.

Produto

• descoberta;
• requisitos;
• métricas;
• prototipação;
• priorização.

Comunicação

• conversar com clientes;
• apresentar soluções;
• explicar arquitetura;
• escrever documentação;
• conduzir reuniões.

Negócio

• entender processos;
• identificar gargalos;
• calcular impacto;
• entender custo;
• medir resultado.

É justamente essa combinação que torna o perfil diferente de um desenvolvedor focado exclusivamente em implementação.

Um exercício para começar hoje

Pegue um sistema que você conhece.

Pode ser:

• um projeto PHP;
• um Drupal;
• um e-commerce;
• um sistema da empresa;
• um projeto pessoal.

E faça cinco perguntas:

1. Qual é o problema mais caro ou demorado desse sistema?

2. Qual parte desse processo é manual?

3. Quais sistemas precisam conversar entre si?

4. Onde uma ferramenta ou agente de IA poderia ajudar?

5. Como eu provaria que minha solução funcionou?

Depois tente construir uma pequena POC.

Não comece pensando em:

"Qual framework de IA devo usar?"

Comece pensando:

"Qual problema estou tentando resolver?"

Essa mudança de mentalidade é provavelmente uma das partes mais importantes do FDE.

O futuro não é apenas escrever código mais rápido

A IA está tornando o desenvolvimento de software cada vez mais rápido.

Isso pode parecer uma ameaça para quem pensa que o principal valor de um desenvolvedor é digitar código.

Mas existe outra forma de enxergar.

Se produzir código fica mais barato e rápido, aumenta o valor de quem consegue:

• identificar problemas;
• tomar decisões técnicas;
• entender sistemas complexos;
• conectar diferentes tecnologias;
• conversar com usuários;
• validar soluções;
• lidar com sistemas legados;
• trabalhar com IA;
• colocar software em produção.

É justamente aí que o conceito de Forward Deployed Engineering se torna interessante.

Para um desenvolvedor PHP, a mensagem não precisa ser:

"Abandone PHP e vá para IA."

Muito pelo contrário.

Pode ser:

"Use tudo que você já sabe sobre engenharia de software como base e adicione a capacidade de trabalhar com IA, integrações e problemas reais de negócio."

PHP continua sendo uma ferramenta.

Drupal continua sendo uma ferramenta.

Symfony continua sendo uma ferramenta.

IA é mais uma ferramenta.

O diferencial está em saber quando, onde e por que usar cada uma delas.

Conclusão

Forward Deployed Engineering representa uma mudança interessante na forma de pensar a carreira de engenharia de software.

O profissional deixa de ser apenas alguém que recebe requisitos e entrega código.

Ele se aproxima do problema.

Entende o contexto.

Conversa com as pessoas.

Projeta a solução.

Constrói rapidamente.

Integra sistemas.

Usa IA quando faz sentido.

Coloca em produção.

Mede o resultado.

E melhora continuamente.

Para quem está no ecossistema PHP, isso não significa começar do zero.

Seu conhecimento de backend, APIs, bancos, Drupal, Symfony, integrações e sistemas legados continua sendo extremamente útil.

A diferença é que agora você pode adicionar uma nova camada:

IA + agentes + ferramentas + MCP + automação + visão de negócio.

E talvez o próximo passo da carreira não seja simplesmente se tornar um desenvolvedor que escreve código mais rápido.

Talvez seja se tornar um engenheiro capaz de resolver problemas maiores, usando código, IA e todas as ferramentas disponíveis para chegar ao resultado.

Para continuar estudando

A documentação oficial da OpenAI possui materiais sobre ferramentas, Agents SDK, agentes, guardrails e observabilidade.

Para quem trabalha com PHP, vale também explorar o MCP PHP SDK, que permite criar servidores e clientes MCP diretamente no ecossistema PHP.

E, principalmente: não fique apenas estudando. Construa.

Escolha um problema real, faça uma POC pequena e tente levar a solução até um ambiente funcionando.

É aí que o conhecimento começa a virar engenharia.