# Cresta's Senior FDE job posting: every line is a task at the customer's site

> Behind each bullet point in the posting sits a concrete task inside a customer's contact centre stack, and the best way to prove you can do it is to build a small version yourself.

Original: https://fdetimes.net/en/guides/cresta-senior-fde-job-posting-decoded/

You open Cresta's posting for a Senior Forward Deployed Engineer (AI Agent), published on 13 October 2026 for remote candidates in Australia, and see a familiar list: Python, Golang, cloud, DevOps, LLMs, project management.

Skim it and it looks like any other engineering posting. Read it closely and each line translates into a concrete task you will perform on a customer's systems, even though the role is remote.

The skill to learn here is not specific to Cresta. It is how to read an FDE job posting: translate each line into the work it implies, then build a small piece of evidence for each task. Candidates who do this get through the CV screen more easily, and walk into the technical assessment having already done a version of the work themselves.

## The verbs in a posting say more than the nouns

The opening sentence of the responsibilities section contains four verbs: develop, configure, deploy and optimise AI agents on Cresta's platform and tools. That sequence is the life cycle of an engagement. You do not build a product from scratch; you take an existing platform and make it work for one specific customer.

To understand what "make it work" means, look at the product. Cresta describes itself as a unified platform for both human agents and AI agents at enterprise scale.

An analysis by eesel AI, updated in May 2026, says Cresta's AI Agent handles voice, chat and SMS, and connects to other systems through API-based function calling as well as MCP support.

An older detail matters more. As early as 2021, Cresta's blog wrote that the product was built to integrate with and run alongside the contact centre software customers already use. So an FDE here almost always works inside someone else's system, with data, limits and processes they do not control.

## Each requirement is a task at the customer's site

The table below translates the main lines of the posting into real work, and shows how you can prove each one before applying.

| Line in the posting | Real work at the customer | Evidence to have |
|---|---|---|
| Integrate agents with APIs, databases, CRMs | The agent must look up invoices, orders and customer records mid-conversation | A tool that calls an API, with a timeout and a fallback |
| Python and Golang | Write the agent logic, write middleware services that run reliably | The same service written in both languages |
| Cloud (AWS, GCP or Azure) and DevOps | Containerise, ship through CI/CD, monitor once live | A repo with a Dockerfile, a CI pipeline and a dashboard |
| LLMs and prompt engineering (strongly preferred) | Tune prompts when the agent answers wrongly on real data | A test question set with results before and after the fix |
| Set milestones, plan, coordinate internally | Deliver on time when many teams are involved | A deployment plan with milestones and risks |

The posting asks for at least 3 years of full-time experience in software development, consulting or AI/ML engineering. All three paths count equally, so a backend engineer who has never worked on AI still has a chance, provided they can prove the Python and Golang line and the cloud and DevOps line.

## Example: an agent that looks up an invoice while the customer is on the line

Imagine a telecoms operator that wants an AI agent to answer "how much is my bill this month?" on the voice channel. The data lives in the operator's billing system, not in Cresta. Your job is to write a tool the agent can call through function calling.

```python
import requests

BILLING_URL = "https://billing.example-telco.internal"

TOOL_SPEC = {
    "name": "get_open_invoice",
    "description": "Fetch the unpaid invoice for a customer whose phone number has been verified",
    "parameters": {
        "type": "object",
        "properties": {"phone": {"type": "string"}},
        "required": ["phone"],
    },
}

def get_open_invoice(phone: str) -> dict:
    try:
        r = requests.get(
            f"{BILLING_URL}/invoices",
            params={"phone": phone, "status": "open"},
            timeout=2.5,  # on a call, a long silence is a failure
        )
        r.raise_for_status()
    except requests.RequestException:
        # the customer's system failed: don't guess, hand off to a human
        return {"ok": False, "action": "handoff_to_human"}

    items = r.json().get("items", [])
    if not items:
        return {"ok": True, "invoice": None}
    inv = items[0]
    return {"ok": True, "amount": inv["amount"], "due": inv["due_date"]}
```

The API call itself takes only a few lines. The value lies in three decisions around it, and those are the decisions interviewers want to hear you explain.

The first decision is the timeout. On chat, a five-second wait is acceptable; on a call, five seconds of silence makes the customer think the line has dropped. The 2.5-second figure here is an assumption for illustration; on a real project you measure the latency of the customer's API before choosing.

The second decision is returning `handoff_to_human` rather than letting the model improvise. An agent that cannot get the data but answers anyway is an agent inventing a bill amount. Because the platform serves both human agents and AI agents, transferring the call to a person is the natural fallback.

The third decision is distinguishing "no invoice" from "error". The two cases lead to entirely different answers for the customer, and the prompt has to teach the agent to say the right one in each case.

**Key point:** Calling the API is a few lines; the value lies in what the agent does when the customer's API does not respond.

## From example to application: work in this order

Start with exactly the tool above, run it against a mock API you write yourself, and add ten test questions, including numbers that do not exist and an API that hangs. Record how many the agent answers correctly before and after you tune the prompt. That is the evidence for the LLM and prompt engineering line, which the posting explicitly marks as strongly preferred.

Next, rewrite the mock billing service in Go. The posting asks for both Python and Golang, so a repo with the same service in both languages answers that line directly. Containerise it, add a CI pipeline that runs the tests, and attach a latency metric: those three things cover the cloud and DevOps line in full.

Finally, write a one-page hypothetical deployment plan for the operator: the milestones, which of the customer's teams must grant API access, and which risks could cause delays. The posting asks FDEs to set their own milestones, plan deployments and coordinate with internal teams to deliver on time, so this plan is direct evidence for that line.

## The CoderPad round and common mistakes

According to the posting, candidates who pass the CV screen take a self-paced technical assessment on CoderPad. The CV is the first gate, so it should describe work you have done rather than list technologies.

A simple template: "Integrated an agent with customer system X via API Y, reducing Z", where Z is a number you actually measured.

The first mistake is listing "LLM, RAG, agents" under skills with no test suite to back it up. The second is assuming an FDE will replace the customer's system, when Cresta itself says the product is built to run alongside existing contact centre software. The third is skipping Go in the belief that AI only needs Python.

Another Cresta posting shows the next step on this path: a Forward Deployed Engineering Manager role, posted in January 2026 for remote candidates in the US, which requires at least 2 years of managing, mentoring and developing engineering teams, and a willingness to travel 10-25% of the time to meet customers and attend events.

The planning and coordination you practise today is the foundation for that step.

Good readers of job postings do not count how many keywords they match. They ask whether they have done this work for anyone yet, and if not, they build a small version of it this weekend.

**Try this week:**

- Write a function-calling tool that calls a mock API (invoices, orders or appointments), with a timeout, handling for the not-found case and a handoff to a human agent on error.
- Rewrite that service in Go, containerise it, and add a CI pipeline that runs the tests plus a metric that monitors latency.
- Rewrite three lines of your CV using the template: the customer's system, what you integrated, the before-and-after number.

## Sources

- [Remote Senior Forward Deployed Engineer (AI Agent) at Cresta - Jobicy](https://jobicy.com/jobs/155182-senior-forward-deployed-engineer-ai-agent)

- [Forward Deployed Engineering Manager @ Cresta | Simplify Jobs](https://simplify.jobs/p/dc9189ee-f488-48a5-b7d6-17090cc1eb20/Forward-Deployed-Engineering-Manager)

- [A deep dive into Cresta in 2026: Features, pricing & a modern alternative | eesel AI](https://eesel.ai/blog/cresta)

- [Investing in Cresta: Supercharging Agents in Real-Time](https://cresta.com/blog/investing-in-cresta-supercharging-agents-in-real-time)