Building an Agentic Workflow: Orchestrating a Multi-Step Software Engineering Interview

As language models evolve, so does the way we build intelligent systems. One emerging pattern is the agentic workflow—a coordinated sequence of tasks in which an AI agent interacts with external tools and APIs, makes decisions, and executes complex flows autonomously.

But intelligence alone isn’t enough. Large language models excel at reasoning and response generation, yet they fall short when it comes to real-world execution. Managing state, coordinating asynchronous tasks, handling tool invocation, and ensuring reliability across multiple steps remain key challenges. That’s where orchestration comes in.

By combining LLMs with a robust workflow engine, we can design resilient, multi-step systems that bridge reasoning with action. In this guide, we’ll walk through an agentic workflow that automates a full software engineering technical interview—from candidate intake to interview questions, evaluation, and report delivery.

Example: Agentic interview app

Let’s build an application that mimics a human-led coding interview, where:

• The candidate enters their details.
• An LLM agent conducts the interview by generating a series of leetcode-style programming questions, which the candidate responds to in a sequence.
• The agent scores answers and provides feedback.
• A formatted transcript of the interview is generated.
• A final report is emailed to the candidate.

This multi-step process involves reasoning (via OpenAI), external tools (Google Docs and SendGrid), and orchestration (Orkes Conductor).

To build it, we’ll use the following components:

Agentic Interview App flow

• Frontend (Next.js)–Provides the user interface for candidate interaction. It captures user input (name, language, email) and streamlines the interview conversation.
• Backend (Python)–Acts as the trigger point for the workflow. It starts the Conductor workflow and serves as middleware to process frontend user input to the backend.
• OpenAI–Provides the reasoning layer. Generates questions, interprets responses, and guides the flow through hints and feedback.
• Google Cloud (Docs API)–Generates and formats the interview transcript as a sharable document.
• SendGrid–Send the final report and feedback to the candidate via email.
• Orkes Conductor–Orchestrates the entire workflow: managing state, coordinating tasks, handling API integrations and logic.

Now, let’s walk through how these tools come together to form the agentic interview application.

Building an agentic interview app

You can follow this tutorial using the free Developer Playground. Create an account to get started.

We’ll build an interview app powered by the following Conductor workflow:

Interview Agentic Workflow in Orkes Conductor

After gathering the candidate details, the interview will begin. Conductor’s Start Workflow task then starts the Core Interview Loop workflow and generates a coding question using OpenAI. It then enters a loop to collect and evaluate the candidate’s responses (with support for hints or simplifications), finally scoring the answer and storing a structured evaluation as a scorecard.

Core Interview Loop Workflow in Orkes Conductor

Now, here’s how you can create an agentic interview application on your own.

Step 1: Clone the repository

The source code for this example project is available in this GitHub repository. Clone it to your local machine:

git clone https://github.com/conductor-oss/awesome-conductor-apps/

Open the project and navigate to the interview app folder:

cd python/interview_agentic_app

Step 2: Get credentials and set up environment variables

This application interacts with multiple tools and APIs. You’ll need to configure a few credentials before running it locally.

Access key and secret from Conductor

Get the access key and secret from Developer Playground by creating a new application from Access Control > Applications. Set the Application role to Worker and Metadata API.

Generate the access key and secret.

Generating access key and secret from Orkes Conductor

Open your project in the IDE of your choice and set the following environment variables:

export CONDUCTOR_SERVER_URL=https://developer.orkescloud.com/api
export CONDUCTOR_AUTH_KEY=
export CONDUCTOR_AUTH_SECRET=

OpenAI API key

Generate your API key from the OpenAI platform, then set the environment variable:

export OPENAI_API_KEY=

Google authentication credentials

Google authentication credentials are required to access Google APIs. Ensure Google Docs API is enabled on your GCP project.

Create a service account in your Google Cloud console and download the JSON key file. It will be named something like project-name.json.

Creating service account key from GCP console

Next, we need to stringify the contents of the JSON file using the following command:

python3 -c 'import json; print(json.dumps(json.load(open("/project-name.json"))))'

Copy the output (the stringified JSON), then set the environment variables:

export GOOGLE_SERVICE_ACCOUNT_JSON=''
export ENV=prod

SendGrid API key

SendGrid automatically sends the final interview summary and feedback to the candidate via email.

Start by creating an account on SendGrid, then create and verify the sender email address. Next, generate an API key from SendGrid.

Generating API key from SendGrid

Now, set the environment variable for your API Key:

export SEND_GRID_API_KEY=

Then, set the environment variable for your verified sender email:

export SEND_GRID_EMAIL_ADDRESS=

Finally, update your workflow JSON to use this sender email. Navigate to python/interview_agentic_app/resources/interviewAgenticWorkflow.json file.

• Go to line 878 and replace the from.email value:

//workflow JSON

 "from": {
                  "email": "" //Line 878
                },
                "subject": "Thank you ${workflow.variables.name} for interviewing with Orkes",

• Go to line 996 and replace the from.email value:

//workflow JSON 
                "from": {
                  "email": "" //Line 996
                },
                "subject": "Thank you ${workflow.variables.name} for interviewing with Orkes",

Step 4: Start the backend server

This step launches the Python-based backend that listens for incoming requests and triggers the Conductor workflow.

Set the Python path:

export PYTHONPATH=/[PATH_TO_REPO]/awesome-conductor-apps/python/interview_agentic_app

Create and activate a virtual environment:

python3 -m venv venv
source venv/bin/activate

Install required dependencies:

pip3 install -r requirements.txt

Start the backend server:

cd workflow
python app.py

Step 5: Start the frontend server

This starts the Next.js frontend, where candidates can enter their details and take the interview in an interactive chat UI.

Open a new terminal and navigate to your project:

cd python/interview_agentic_app

Next, navigate to the frontend directory:

cd interview-chat

Install dependencies:

npm install --legacy-peer-deps

Start the frontend server:

npm run dev

The app should now be running locally. To start the interview, open it in your browser at http://localhost:3000.

Step 6: View the interview app in action

Once the frontend and backend stacks are up and running, open the UI in your browser—this launches the interview experience locally.

Agentic Interview App UI

In your Developer Playground, you’ll notice that the required OpenAI integrations, AI prompts, and workflow definitions are automatically created.

Resources created in Developer Playground

As the candidate proceeds, the Interview Agentic Workflow is triggered. Each interview question is handled by a separate workflow, Core Interview Loop. So, for a three-question interview, three workflows run in sequence using Conductor’s Start Workflow task.

Triggered workflows in Developer Playground

Once the interview is complete, a thank you email with personalized feedback and scores is instantly sent to the candidate via SendGrid API.

Thank you email triggered via SendGrid on interview completion

In parallel, a fully formatted Google Docs transcript is generated and stored in Google Drive. The interviewer and candidate are granted access, and a shareable link is shared via another email.

Interview transcript generated and stored in Google Docs

That’s it—you’ve now built a fully automated coding interview for a Software Engineer, from candidate intake to evaluation and reporting.

With the core workflow in place, you can easily tailor it to your own needs: customize the prompts, add more questions, or plug it into tools of your choice.

This agentic interview app isn’t just for demos—it’s built for production. You can deploy the backend on platforms like Render and the frontend on Vercel, with your Conductor workflows running in the Orkes Cloud.

What next?

Now that you’ve built and tested your agentic interview workflow, here are a few ways you can take it further:

• Add a progress tracker–Show candidates how they’re doing after each question to make the experience more engaging.
• Plug into ATS or HRIS–Send the final report straight to your ATS or HR dashboard for easier review.
• Use it beyond coding–Replace coding questions with behavioral prompts or design discussions to adapt the workflow for non-technical interviews.

Wrapping up

This tutorial walked you through building a complete agentic workflow—one that goes beyond single-shot prompts to orchestrate a real-world, multi-step interview process. Using OpenAI for reasoning, Google Docs for formatting, SendGrid for communication, a modern frontend and backend stack, and Orkes Conductor at the core, you now have a robust foundation for deploying agentic workflows in production.

Whether you’re building technical assessments, onboarding flows, or multi-agent decision systems, Conductor gives you the structure to scale—with full control over inputs, logic, and integrations.

Explore more AI-powered workflows built with Conductor

• Agentic cybersecurity monitoring system
• Article summarizer
• AI-powered document classification system
• Building a retrieval augmented generation system
• Multilingual translation with LLMs

Try building and running your first agentic workflow using the free Developer Playground.