Forward-deployed engineer vs. solutions architect: who designs, who ships

AI pilots often lose momentum after the demo. The platform works, but connecting it to how a business actually runs takes more than a good design. Two roles are meant to close that gap: the solutions architect and the forward-deployed engineer (FDE).

Both roles call for technical depth, solution design, and close work with clients. On job boards, the titles often describe overlapping work, and one company's FDE can look a lot like another company's solutions architect. As demand for AI deployment grows, that confusion is spreading across the market. But the roles sit at different points in the customer lifecycle, and they answer to different measures of success.

The clearest way to compare a forward-deployed engineer vs. a solutions architect is to ask what each person is accountable for delivering. A solutions architect maps product capabilities to the customer's stated requirements. An FDE embeds in the customer's environment, builds the working solution, and takes it into production.

What is a solutions architect?

The solutions architect role centers on design, working with stakeholders to understand what the customer needs. From there, they decide how the platform, its integrations, and the customer's existing systems should fit together. Their solutions architecture becomes the plan the implementation team follows.

Typical solutions architect work includes:

• Gathering requirements and constraints from technical and business stakeholders
• Producing architecture diagrams, solution designs, and reference architectures
• Building demos or a proof-of-concept to validate an approach
• Guiding decisions on security, scale, and integration patterns
• Advising the implementation team as the design moves into delivery

Solutions architects may write code, and many build a working prototype along the way. But in most organizations, they aren't the person accountable for taking a system into production. Delivery ownership varies by company.

What is a forward-deployed engineer?

A forward-deployed engineer, sometimes called a forward-deployed software engineer, is a hands-on engineer who embeds directly in the customer's business to build and deploy a working solution.

The gap between platform features and business results is a problem of operational translation, and that translation only happens close to the work. FDE work usually follows three stages:

1. They shadow real users. FDEs sit with the people doing the work, such as adjusters, underwriters, and analysts, to see where time goes, where approvals stall, and where tasks depend on judgment nobody has written down.
2. They prototype against real data. FDEs build something that calls real APIs, reads real documents, and works with the customer's legacy systems. Once a business owner sees it running, the question shifts from "Will this work?" to "How should people and AI agents divide the work?"
3. They ship the seam. FDEs build the boundary between what AI agents handle and what people review into production code, along with the integrations, error handling, and escalation paths a live system needs.

Writing production code is central to FDE roles. FDEs build custom integrations, connect data pipelines, and in some cases adapt custom models to fit real workflows.

For a full introduction to the role, read What Is a Forward-Deployed Engineer?

Forward-deployed engineer vs solutions architect: key differences

The roles overlap. A solutions architect may write code and guide complex deployments, and an FDE also makes architecture decisions and helps stakeholders understand what's technically possible. The difference is in where each role spends its time and what it's accountable for delivering.

How each role approaches a project

Imagine an insurance claims process with seven stages, where the company wants AI agents to handle some of the work. Both roles contribute, but to different parts of the project.

The solutions architect’s work covers how the platform connects to the claims system, which integration patterns to use, and how the design meets security requirements. It answers whether the technology can support the process.

The forward-deployed engineer’s work covers how each stage will actually run. Working with the claims team, the FDE decides which steps an agent can handle, which must stay with a person because of regulatory exposure, and where handoffs should change by claim type. Then they build those decisions into the production system.

Agentic projects need both. But they tend to stall when nobody owns the second part, because the boundary between agent and human never gets designed around how the business actually works.

Where solutions engineers and sales engineers fit

Solutions engineers and sales engineers often get mixed into this comparison. Solutions engineers and sales engineers usually support the sales cycle: running demos, answering technical questions, and helping the customer evaluate whether the product meets their needs. These roles often include variable pay tied to closed deals, which is a useful signal of where a role sits.

The same account may need all three over the customer lifecycle. A sales engineer helps with the technical evaluation, a solutions architect works through the architecture, and an FDE builds and deploys the solution after the deal closes. Customer engineer roles, implementation engineers, and professional services teams add more overlap, and companies use these job titles differently.

How their skills differ

Both roles need technical depth and strong communication, but the emphasis differs.

Solutions architects tend to be strongest at:

• Enterprise architecture, security, and integration patterns
• Translating requirements into designs that scale across many customer implementations
• Guiding stakeholders through technical trade-offs

Forward-deployed engineers tend to be strongest at:

• Writing production code and taking a build through deployment
• Working with real data, APIs, and legacy systems
• Asking business owners the questions that fill gaps in the requirements
• Turning real workflows into working software

A strong software engineer may have the technical skills for FDE work but need support with customer-facing work. A strong solutions engineer may know how to work with customers but have less experience taking a system into production. The best FDE candidates combine both.

The roles also shift as a product matures. Early on, FDEs often solve problems the core product can't handle yet, and they feed what they learn back to the engineering team. Over time, those fixes can become product features, and the work moves toward repeatable designs that solutions architects can apply across many clients.

Which role does your team need?

Start with where your AI projects typically struggle.

You likely need a solutions architect if the problem is upstream. Nobody has defined how a platform should fit your systems, security requirements are unclear, or several teams need a shared design before anyone builds.

You likely need a forward-deployed engineer if the problem is downstream. The proof-of-concept might work, but deployment stalls when it meets real data and legacy systems. Nobody owns the custom integrations, or the team hasn't decided when a person should step in for the agent.

Many organizations need both at different stages. Before any company hires for either role, define who'll write code, who'll own deployment, and how internal teams will take over the work. Job postings alone won't answer those questions. If you can only make one hire, start with one FDE, pair them with one business owner who knows the process inside and out, and give them ninety days and a defined workflow.

Final thoughts

Solutions architects and forward-deployed engineers aren't competing roles. The architect designs how the technology fits. The FDE makes it work inside the customer's business and proves the value in production. As more AI pilots move toward deployment, the gap between those two types of work is where many projects succeed or fail.

If you're looking to start with an experienced engineer, FullStack's Forward-Deployed Engineers embed with your team to build the workflow you need and get it running in your systems.

^{Go deeper with our Forward-Deployed Engineer white paper, which explains what an FDE does and how to tell if your project needs one.}