AI Application Development Roadmap: From Backend Foundations to Agent Engineering

Many computer science students get stuck on the phrase "learn AI": Should you jump straight into large language models? Start with AI Agents? Or do you even need to learn traditional backend development? This 748-episode Agent tutorial on Bilibili isn't about training hundred-billion-parameter models — it's focused on AI application development: building real systems on top of existing LLMs that ordinary people can actually use. This is precisely what 90% of companies need right now, and it's the most realistic career path for typical undergraduate students.

The Three-Layer Structure of the AI Industry: Don't Conflate "Learning AI" with "Training LLMs"

The most common misconception is that learning AI means training large models and becoming an algorithm engineer. The real AI industry is far more complex. A complete AI system — from underlying data, compute, and chips, to LLM training in the middle, to user-facing AI products — requires many different types of talent working together. Technically, the entire industry can be broken into three layers.

The infrastructure layer provides the foundation that makes AI run. It includes data engineers and AI data specialists (responsible for data collection, cleaning, annotation, anonymization, and compliance), with starting salaries around ¥10K–18K/month; MLOps and compute scheduling roles (resource scheduling, distributed training, GPU cluster operations), which lean toward computer networking, operating systems, cloud computing, and distributed systems — typically requiring a master's degree, with annual salaries of ¥200K–350K, and senior architects earning ¥800K–1M; and the highest-barrier role of all, AI chip design, which focuses on computer architecture and CUDA optimization, typically requires a graduate degree from a top-tier university, and commands ¥1.5M–2M annually at the senior level. The author bluntly notes that some infrastructure roles (such as data annotation) involve repetitive work with limited growth value and aren't recommended as a primary career target.

The model layer is responsible for building AI's brain — centered on the research and training of large models. Two key concepts here: foundation models (general-purpose LLMs like GPT, Doubao, and DeepSeek) and post-trained models (foundation models fine-tuned for specific industries). LLM algorithm engineers design and optimize model architectures (Transformer frameworks, training methodologies, parameter optimization) — a heavily research-oriented role with annual salaries of ¥500K–1.2M. LLM fine-tuning engineers (SFT track) represent one of the fastest-growing areas of enterprise demand: instead of training models from scratch, companies use internal data to run supervised fine-tuning (SFT) and LoRA fine-tuning on existing models, making them more attuned to specific domains like banking or finance — annual salaries of ¥400K–800K. Reinforcement learning engineers (RLHF) continuously optimize models through reward mechanisms.

The Application Layer: The Most Realistic Entry Path for Undergraduates

The application layer puts the brain inside a product, making it usable for everyday people. This is where enterprise demand is highest and where typical students have the closest match. The author uses a fitting analogy: the infrastructure layer builds the roads, electricity, and water supply (can AI run?); the model layer cultivates a super-intelligent brain (does AI have capability?); the application layer turns all of that into actual products (does AI deliver value?).

The core roles in the application layer include several types. AI full-stack engineers are among the most in-demand positions at mid-to-large tech companies over the past two years — essentially traditional software development (Java/C++/Python, frontend/backend, databases, APIs) combined with AI capabilities (LLM integration, prompt engineering, RAG knowledge base technology). AI application developers focus on turning AI capabilities into software products users can actually use — such as AI customer service agents, AI office assistants, and AI educational tools. AI Agent engineers are the hottest specialty right now, covering Agent framework design (task decomposition, tool invocation, workflow orchestration) and multi-agent collaboration. The application layer also includes AI QA engineers (an evolution of traditional software testing into the AI era) and AI product managers who bridge user needs with AI capabilities in product design.

Learning Roadmap: From Traditional Backend Foundations to AI Application Deployment

For the application layer — where market demand is highest — the author lays out a clear learning sequence. The first phase is traditional backend foundations. Many students want to skip this and jump straight to AI, but without a solid base, what you'll build is just a toy demo that can't go live.

The backend curriculum, in order: C (building foundational programming intuition and systems-level thinking), Java basics (OOP, I/O, collections, exception handling), data structures and algorithms (linked lists, trees, algorithm practice — required for interviews and foundational for RAG vector retrieval later), databases (slow MySQL will directly tank your AI Q&A response time), intermediate and advanced Java with Spring Boot, Spring Cloud microservices, Redis, and message queues (MQ). Completing this portion puts you at the technical level of a traditional software engineer.

The second phase is the core AI application development curriculum: Python basics and Python web development, an LLM fundamentals course (understanding LLM limitations, knowing when to use RAG vs. Agent, understanding what MCP is), prompt engineering, Vibe Coding (using AI to assist code writing), enterprise-grade RAG development (solving the pain point of LLMs not knowing private organizational data — a top topic in campus recruiting), Agent development in practice (LangChain, LangGraph, MCP protocol), and LLM fine-tuning (LoRA, QLoRA). Completing this entire path brings you to the level of an AI application development engineer.

---

Agents and the MCP Protocol represent the most cutting-edge engineering direction in AI application development today, and understanding them helps clarify your learning goals. Traditional LLM usage is a single-turn "input → output" Q&A model. Agents go further by introducing a "perceive → plan → act" loop: the model can actively decompose complex tasks, select and call external tools (such as search engines, code executors, or database query interfaces), and continuously adjust its actions based on tool outputs until the goal is achieved. LangChain and LangGraph are the dominant Agent development frameworks today — LangChain provides foundational components for tool calling and chain orchestration, while LangGraph uses a graph structure to support more complex multi-step workflows with conditional branching. MCP (Model Context Protocol), proposed by Anthropic, is an open protocol designed to standardize communication between AI models and external tools/data sources — analogous to USB for hardware: it allows tools from different vendors to be called uniformly by different AI models. It's an important step toward making the Agent ecosystem more engineering-ready and standardized.

---

Project Practice and Career Directions

Once the technical skills are in place, real-world projects are the missing piece. The author recommends starting simple and increasing complexity gradually. Entry-level: a single-turn RAG Q&A system — just getting a local demo running is enough. Intermediate: a multi-turn conversational system built on RAG, using FastAPI, RAG, Redis, and MySQL — deployable online, supporting multi-user login and document uploads, and strong enough to be a resume highlight. Enterprise-level: a microservices-based AI knowledge base system or MCP intelligent agent system — involving Java microservices, Docker, RAG, Agent, and MCP — close to real enterprise engineering, ideal for targeting top companies. The author specifically advises freshmen and sophomores with weaker foundations: don't start by trying to build enterprise-level projects to show off. Get the minimum viable version running first, then add complexity.

On the job market, relevant roles include AI application development engineer, LLM Agent developer (Agent + MCP), and AI full-stack engineer. Companies hiring for these roles include major internet companies (ByteDance, Alibaba, Tencent, Baidu — building enterprise knowledge bases, office assistants, and internal AI customer service), AI startups (vertical applications in legal AI, educational AI, etc., all requiring heavy RAG and Agent work), traditional software companies integrating LLMs into existing systems, and B2B enterprise service companies deploying private AI knowledge base solutions.

It's important to note: this roadmap is designed for undergraduates targeting employment, especially students from non-elite universities or standard four-year programs who want to be job-ready at graduation. It is not intended for master's or PhD students pursuing LLM training, algorithmic research, computer vision (CV), or foundational NLP research — those tracks require deeper theoretical grounding and stronger mathematical ability.

---

FastAPI appears repeatedly in this roadmap and deserves a dedicated explanation. It's a Python backend framework that automatically generates API documentation based on Python type annotations, with performance comparable to Node.js and Go. It's particularly well-suited for quickly building backend interfaces for AI services — for example, receiving user-uploaded documents, calling LLM APIs, and returning generated results. Compared to the more traditional Flask, FastAPI natively supports asynchronous request handling, giving it stronger concurrency performance in I/O-intensive scenarios like LLM inference. For application-layer engineers, FastAPI typically serves as the layer that "wraps AI capabilities into HTTP endpoints" — the critical glue connecting frontend products to backend LLM calls, and the engineering foundation that makes a project "deployable and accessible to multiple users" on a resume.

---

Practical Advice for New Students

The author closes with several grounded recommendations: don't skip traditional backend and jump straight to AI — your foundation will crack under pressure. Freshmen and sophomores should prioritize programming fundamentals, data structures and algorithms, and databases, while experimenting with small RAG demos to get a feel for AI development. By sophomore year, aim to have solid Java and Python backend skills, deep RAG experience, and at least one production-deployable project — that combination is enough to start applying for internships. Be deliberate about distinguishing must-learn from optional content; don't try to learn everything. And always prioritize getting a project to actually run, deploy to the cloud, and be accessible to real users — that's worth far more on a resume than a list of technology buzzwords.

The value of this roadmap lies in giving confused students a clear map. It doesn't promise to turn you into a large model research expert — but for the AI application engineering roles that make up the vast majority of market opportunities, it provides an executable path to get there.

Background: Key Concepts Explained

RAG (Retrieval-Augmented Generation) is a key technology frequently referenced in the application layer and worth understanding upfront. Once a large model finishes training, its knowledge is essentially "frozen" — it can't access a company's private documents or the latest information. RAG's approach: when a user asks a question, the system first retrieves relevant document chunks from a private knowledge base, then feeds those chunks together with the question into the LLM, allowing the model to answer based on "reference material." This eliminates the need to retrain the model while giving it access to proprietary content. Vector databases are the core component of RAG — they convert text into high-dimensional numerical vectors for storage, and at retrieval time, use vector similarity calculations to quickly find the most relevant passages. This is exactly why data structures and algorithms (especially vector retrieval) are cited as a necessary backend foundation.

SFT (Supervised Fine-Tuning) and LoRA are another pair of core concepts. SFT involves further training a pretrained model on labeled "question–answer" pairs, adapting it to specific business styles and domain knowledge. LoRA is a parameter-efficient fine-tuning technique: rather than updating all of a model's parameters, it inserts low-rank matrices alongside the original weights and trains only those additional parameters — dramatically reducing GPU memory consumption and training costs, making fine-tuning feasible on standard enterprise GPU servers.