Full-Stack Agent in Practice: One Codebase Running Across Five Clients and Dual Server Architectures

A hands-on Bilibili course breaking down the full-stack Agent engineering path and capability list for five clients plus dual servers.
The article interprets a Bilibili "AI Full-Stack Project in Practice" course, showing how tech hiring is shifting from single-client roles to requiring full-chain skills across five clients (web, desktop, mobile, mini programs, H5) plus dual server architectures. The course uses 30 days and ten topics, with an integrated project replicating DeepSeek Harness; the server runs NestJS and FastAPI in parallel, supported by Docker orchestration for multi-service debugging. It demonstrates Agent calculator tool-call traces rendering across iOS, Android, mini programs, and desktop, and notes the course targets developers with some foundation.
Why High-Paying Jobs Now Require "All Clients + Dual Servers"
In today's tech hiring market, one signal is becoming increasingly clear: pure frontend or pure backend roles are being squeezed, while engineers who can connect the entire frontend chain and understand multiple server-side architectures are becoming the core profile for high-paying positions. This Bilibili course, "AI Full-Stack Project in Practice," breaks this trend into ten topics, attempting to take developers through a brutal 30-day upgrade from full-stack to Agent development.
The instructor mentions target salary ranges of 30k, 40k, 50k—positions where "the base keeps getting higher." The technical breadth required for these roles is no longer just "can write pages" or "can call APIs," but rather having command over an entire all-client, all-site architecture system. The capability checklist given in the course includes: on the frontend side—web, desktop, mobile, mini programs, and H5, the complete chain; on the server side—Docker orchestration, TypeScript server-side rendering and server architecture, Python server architecture, plus additional server architecture layers to come.

This actually answers a very real question: when an Agent application needs to appear simultaneously on iOS, Android, mini programs, desktop, and H5, who handles the unified engineering? Developers who only know a single client can hardly take on this kind of requirement, but engineers who can fuse five clients and dual server systems together happen to match the keywords in the job descriptions.
What the Integrated Practice of Five Clients + Dual Servers Looks Like
The course doesn't stop at listing concepts—it uses one integrated project to string together ten capability lines. The instructor emphasizes that this is not empty talk, but "the final integrated project in practice"—a complete implementation from advanced full-stack to the five-client, dual-server architecture system.
The multi-client nature of the project is the first highlight. In the demo, both iOS and Android are launched simultaneously, running on an iPhone 18 Pro Max simulator, followed by the mini program client and desktop client in sequence. This "one Agent logic, multiple clients running simultaneously" form is exactly the typical demand of multi-client engineering today: business logic converges on the server, while clients handle only interaction and presentation.

What's worth noting is the choice of tech stack. The project is built around replicating the well-known DeepSeekAd Harness framework—the instructor states directly that it "fully replicates DeepSeek Harness." This shows that the value of the hands-on project isn't in building a new wheel, but in taking apart a mature product's engineering structure and walking through it again with both TypeScript and Python stacks, thereby truly understanding the complete chain of an Agent application from client to cloud.
DeepSeek Harness is an Agent runtime and debugging framework built around DeepSeek models, whose core purpose is to provide model invocation, tool (function calling) registration and execution, conversation trace visualization, and similar capabilities. "Harness" in the Agent engineering context typically refers to the shell that strings together the large model, external tools, state management, and frontend observability: the model outputs structured tool-call instructions, the Harness parses and executes them, feeds results back to the model, and exposes each step's trace to the interface. The significance of replicating such a Harness is that learners must simultaneously handle protocol conventions, tool registries, streaming output, and multi-client rendering—rather than stopping at the level of calling an API once.
Dual Server Architecture: NestJS and FastAPI in Parallel
The most noteworthy architectural point of this course is that it builds two server sets: one based on NestJS and one based on FastAPI (Python). In the demo, the instructor starts both services separately and states "I've built two server architectures," with full implementation demos to follow.

The design of dual servers in parallel reflects a contrast between two engineering approaches. NestJS represents server-side rendering and server architecture capabilities within the TypeScript ecosystem, suited for sharing language and type systems with the frontend; FastAPI represents the Python ecosystem's server capabilities in AI scenarios, close to model invocation and data processing. For an Agent application, these two architectures take on different responsibilities, corresponding to the first two of the "three server architecture technology systems" the instructor mentions.
From an engineering perspective, dual servers mean Docker orchestration becomes mandatory. In the demo, the instructor first starts Docker, then runs the orchestration command, then restarts the NestJS service and Python service, and only then reloads the client. This startup sequence itself illustrates the complexity of dependency management under a multi-service architecture—without container orchestration, local debugging of five clients plus dual servers would be nearly unmaintainable.

NestJS is a server framework based on Node.js and TypeScript, organized in layers of modules, controllers, and providers, with deep integration of dependency injection, often compared to Angular's engineering paradigm. Its biggest advantage is sharing TypeScript type definitions with the frontend, so interface contracts can be validated at compile time. FastAPI is a modern async web framework in the Python ecosystem, automatically generating request validation and OpenAPI docs from type annotations, natively supporting async/await, and working smoothly with Pydantic and async model SDKs—hence widely adopted in AI service layers. When running in parallel, the common division of labor is: NestJS handles client-facing BFF and business orchestration, while FastAPI handles model invocation, tool execution, and other compute-heavy logic, communicating via HTTP or message queues.
Complete Chain Demo of Agent Tool Calling
The core interaction demonstrated in the course is having the Agent execute calculator logic: the user enters a number, the Agent recognizes the intent and calls the tool, and the interface simultaneously displays the call trace. The instructor specifically notes that this trace "fully replicates DeepSeek Harness."
The significance of this detail is that it simultaneously exposes three key layers of an Agent application: the client-side interaction layer, the server-side orchestration layer, and the observability layer for tool calling and trace display. Many tutorials cover only one of these layers, but multi-client practice must connect all three—both iOS and Android must correctly render the same set of tool-call trace data, which in turn constrains the server API design.
In the demo, the instructor switches back and forth between clients: first launching on the iOS simulator, then switching to Android to relaunch, reloading on desktop, and clicking the calculator feature on mobile. This "same feature, multi-client verification" process is precisely the hardest part of all-client engineering, and the engineering detail most likely to be probed in high-paying job interviews.
Tool Calling / Function Calling is the key mechanism that distinguishes Agents from ordinary chat applications: developers declare available tools and their parameters to the model via structured schema, and the model returns a "call intent" when needed; the server actually executes the function and sends the result back to the model for continued reasoning. The "call trace" displayed on the interface is generally observable data formed by recording intent parsing, parameters, execution results, and latency in sequence. In multi-client scenarios, this trace is typically delivered by the server in a unified event format, with each client only rendering it—so API design must ensure a stable event structure and incremental push, which is the concrete meaning of "server API design constrained in reverse by multiple clients" mentioned in the original text.
Who This Path Suits, and Its Boundaries
In terms of positioning, this course targets developers who already have some frontend or backend foundation and want to advance toward full-stack Agent development. Ten topics over 30 days, capped with an integrated project, essentially provides a referenceable technical advancement roadmap—the instructor explicitly positions it as a career direction for "the next two, even three years."
Objectively speaking, this kind of "multi-client + dual-server" hands-on course has very high information density—nearly an hour of instruction per session covers everything from architecture analysis to Docker orchestration to multi-client startup. For beginners, following along with five-client debugging directly presents a significant barrier; a more realistic path is to first master one server plus one client, then fill in the remaining clients and servers incrementally. Additionally, the course demo relies on simulators and a local Docker environment; real-world deployment also requires considering build and release pipelines for each client, which the original material doesn't cover.
Overall, the value of this hands-on course lies in breaking down the abstract question of "how to engineer an Agent application into production" into a concrete checklist of five clients and dual servers. For developers who want to build full-stack depth in the Agent direction, it offers a capability map to check off item by item—not a set of code templates to copy directly.
The term "server-side rendering" here has two meanings that need to be distinguished: first, traditional SSR, where the server generates HTML for the first screen to improve loading and SEO; second, in the full-stack TypeScript context, it refers to the frontend framework and server runtime sharing code and rendering logic (like isomorphic solutions such as Next.js and Nuxt). NestJS itself is a pure server framework—what it shares with the frontend is the language, types, and some business code, not page rendering. Understanding this distinction helps clarify what the "TypeScript server-side rendering and server architecture" capability line is really testing: the former leans toward first-screen and isomorphism, the latter toward API layering, authentication, caching, and deployment.
One-line Summary
A Bilibili hands-on course mapping out the full-stack Agent engineering path and capability checklist for five clients plus dual servers.
Paragraph Summary
The article interprets a Bilibili "AI Full-Stack Project in Practice" course, noting that the tech hiring market is shifting from single-client roles to requiring full-chain capabilities across five clients (web, desktop, mobile, mini programs, H5) plus dual server architectures. The course uses 30 days and ten topics, with an integrated project replicating DeepSeek Harness to connect all capability lines; the server runs NestJS and FastAPI architectures in parallel, supported by Docker orchestration for multi-service debugging. The project demonstrates the complete chain of an Agent calculator tool-call trace rendering synchronously across iOS, Android, mini programs, and desktop. The article also notes the course is positioned as an advancement roadmap for developers with some foundation; beginners should first master one client plus one server before expanding, and multi-client build/release pipelines aren't covered in the material.
Related articles

Multi-Agent Collaborative Development: Task Card-Driven Practices for Medium-to-Large AI Projects
A Bilibili creator shares a task card-driven, PM-orchestrated multi-Agent collaboration model with local-first repository state, so any Agent tool can take over a project anytime.

Cursor vs Copilot vs Claude Code: How Laravel Developers Should Choose
Compare Cursor, GitHub Copilot, and Claude Code for Laravel development: an AI-first editor, a plugin for existing editors, and a terminal agent for multi-file tasks and testing — plus workflow-based recommendations.

AgentScope Java Edition: A Practical Guide to Enterprise-Level Agent Frameworks
An in-depth analysis of Alibaba's AgentScope Java enterprise agent framework: contrasting client-side AI and server-side AI, explaining Java's natural advantages in high concurrency and distributed state management, and outlining a complete learning path from core principles to multi-agent collaboration.