JD List: Job Openings at Major Domestic and Overseas Companies

This list answers a very specific question: right now, if you open a job board, what exactly are machine learning roles on the market requiring?

This article does not copy real JDs verbatim, nor does it list time-sensitive information like "Company X is hiring for Role Y"—JDs are fluid, role names drift, and a position open today might be frozen next month. Instead, this article extracts skill combinations that repeatedly appeared across public JDs at major domestic and overseas companies from 2024–2026, and provides reading methods, word frequency, and mapping. What you should take away is a reusable analytical framework, not an expiring list of job openings.

Note on data timing

This article is based on a synthesis of publicly visible job descriptions from company career websites and job platforms (e.g., Maimai, BOSS Zhipin, Liepin) around the writing date (dataAsOf: June 2026), and does not constitute a guarantee of any company's current openings. For specific roles, locations, headcount, and requirements, always refer to official career pages in real time. All "hard requirements / nice-to-haves" mentioned in this article are commonalities distilled from multiple JDs and do not point to any specific company or role.

1. How to Read This List

1. JDs Change, Skill Combinations Are the Constant

First, observe a real phenomenon of role name drift: in 2021, search, content, and e-commerce teams at various companies hired "Algorithm Engineers"; starting in 2024, the same teams began posting "Large Model Algorithm Engineer," "LLM Application Engineer," and "Agent Engineer."

Evolution of role names at the same team over four years (illustrative):

2021  Algorithm Engineer (Machine Learning track)
2022  Algorithm Engineer (NLP track / Search & Recommendation track)
2024  Large Model Algorithm Engineer
2025  Large Model Application Engineer / LLM Algorithm Engineer
2026  Agent Engineer / Multimodal Algorithm Engineer

The core skill set changed little: Python + ML foundations + deep learning + engineering.
But the role name kept changing.

Role names are the market's mood thermometer; skill combinations are the long-term stable skeleton. The first principle of reading a JD: translate the role name into a "skill vector," not memorize the role name itself. NLP Engineer, Search Algorithm Engineer, and LLM Application Engineer might all come from the same team with 70% skill overlap; while two identically named "Algorithm Engineers" in an ad department and a chip department might have completely unrelated requirements.

2. Distinguish "Hard Requirements" from "Nice-to-Haves"

Almost all JDs are structured in two sections: one for "Role Requirements" and one for "Nice-to-Haves / Preferred Qualifications." These sections carry completely different semantics:

	Hard Requirements (Role Requirements)	Nice-to-Haves (Preferred Qualifications)
Actual meaning	You won't get an interview without meeting this	Having it helps; lacking it usually doesn't disqualify you
Typical content	Degree, years of experience, required languages and frameworks	Domain experience, papers, competitions, open source, business background
Screening logic	Filter: fail this and you're immediately filtered out	Rater: among those who pass, creates differentiation
Candidate strategy	Check off one by one, none is optional	Treat as "differentiation material"—having one or two with a story to tell is enough

A common misreading is to treat nice-to-haves as hard requirements and feel anxious: if a JD says "RLHF experience preferred," it doesn't mean you can't apply without RLHF experience. In reality, most nice-to-haves are "nice to have," not "must have." Conversely, if a hard requirement says "familiar with PyTorch" and you've never touched PyTorch, that's a real gap to worry about.

Three signals for distinguishing hard vs. nice-to-have

1. Look at wording: "Proficient in," "mastery of," "X+ years of experience" are usually hard requirements; "experience with XX is preferred," "nice-to-have," "familiarity is a plus" are nice-to-haves.
2. Look at quantity: Hard requirements typically number no more than 5 and are mutually orthogonal; if a JD lists 12 hard requirements, it's actually an "ideal profile," and the real threshold is lower than it appears.
3. Look at role type: Campus recruitment JDs have fewer, broader hard requirements (testing fundamentals); experienced-hire JDs have more, narrower hard requirements (testing fit). Fresh grads checking off experienced-hire JDs one by one is the fastest way to talk yourself out of applying.

3. Three Misconceptions When Reading JDs

• Only reading the role name and company name: That's only reading the cover, not the content. Similarity of role names has only a weak correlation with similarity of skill requirements.
• Only memorizing skill lists: JD lists PyTorch, so your resume writes PyTorch—that's literal matching. When an interviewer asks "what have you trained with it, what problems have you encountered?" you'll be exposed. Skills must be expandable into project stories.
• Only looking at big companies: Big company JDs have standardized wording and fine-grained division of labor, making them good for calibrating standards; but the offers that actually land you the job may come from mid-size companies, unicorns, or vertical domain companies. Standards come from big companies; opportunities come from the whole market.

4. The Right Way to Use This List

After reading, follow these three steps, and the list has done its job:

① Narrow down to 2–3 target roles  →  From Sections 2 and 3 below, pick 2–3 closest to your background
② Check off against the skill map  →  Use [Skill Map](/career/knowledge-map) to mark each item
                                    Know / Don't Know / Partially Know
③ Generate study gap list and set priorities  →  "Don't Know" items in hard requirements are Priority 1
                                                   "Partially Know" items in nice-to-haves are Priority 2

The full methodology of "JD-driven reverse learning" is covered in Job Search Sprint Plan, which turns role requirements into actionable review plans—it's the main thread of that article.

2. Typical Roles at Major Domestic Companies

This section covers six categories of ML roles that have appeared consistently on the career pages of major domestic companies (Alibaba, Tencent, ByteDance, Baidu, Meituan, JD.com, etc.). Each category provides skill requirement breakdowns from 2–3 representative JDs—note: the tables below are commonalities across companies in the same role type, not verbatim quotes from any real JD.

1. Algorithm Engineer · Machine Learning Track

The #1 keyword in domestic hiring, with virtually every major company hiring long-term. Representative JDs fall into three categories:

• Business modeling track (common at Alibaba, Meituan, JD.com): Feature engineering, modeling, evaluation, and deployment loops tied to specific businesses (transactions, risk control, supply chain).
• Foundation platform track (common at Tencent, Baidu): General modeling capability serving multiple business lines; deals with more complex, larger-scale data.
• Risk control / anti-fraud track (common at financial and security departments across companies): Focused on classification and anomaly detection, with strict demands on accuracy, latency, and interpretability.

Skill requirement breakdown (commonalities across three representative JDs):

Dimension	Hard Requirements (almost always present)	Nice-to-Haves (high frequency)
Programming	Proficient in Python; can write quality engineering code	C++ or Java; multithreading and performance optimization
Algorithm fundamentals	Solid ML foundations: supervised/unsupervised/evaluation/feature engineering	Hands-on experience with tree models (XGBoost/LightGBM)
Deep learning	Proficient in at least one DL framework	PyTorch; understanding of Transformer architecture
Data structures & algorithms	Written test topics: arrays/lists/trees/graphs/DP	Competition experience or LeetCode volume
Engineering	Familiar with model deployment and online evaluation processes	Big data tools like Spark/Flink; distributed training
Business/domain	Business understanding and metric decomposition	Vertical domain background (e-commerce/advertising/risk control); proficient SQL

Why "business modeling track" JDs are the hardest to read

The same "Algorithm Engineer" JD might have completely different responsibilities depending on whether it's posted by the transactions team or the research institute. Before applying, use two questions to filter out mismatches: Who uses the model this role builds? (internal decision-making vs. online product) and Is the model evaluated by offline metrics or business metrics? The former determines whether you go deep technically or business-side; the latter determines your daily work after joining.

2. Large Model Algorithm Engineer

The fastest-growing role type since late 2022, by 2026 it has become one of the absolute mainstream directions for algorithm roles at major companies. Representative JDs fall into three categories:

• Pre-training / alignment track (common at Baidu's ERNIE, Alibaba's Tongyi, ByteDance's Doubao): Participate in large model pre-training, SFT, RLHF, and evaluation.
• Application / deployment track (across all business lines): Integrate base models into business, build RAG, Agents, Prompt engineering, evaluation, and iteration.
• Inference optimization track (common at platform departments and cloud providers): Model compression, quantization, serving—turning "can use" into "can afford to use."

Skill requirement breakdown (commonalities across three representative JDs):

Dimension	Hard Requirements (almost always present)	Nice-to-Haves (high frequency)
Languages & frameworks	Python; proficient in PyTorch	Distributed training frameworks (Megatron/DeepSpeed); C++/CUDA
Model knowledge	Solid understanding of Transformer architecture; application paradigms like Prompt/RAG	Fine-tuning (LoRA/full-parameter SFT); RLHF/DPO experience
Training engineering	Understand large-scale training: data pipelines, gradients, memory optimization	Thousand-GPU-scale training experience; inference optimization (quantization/distillation)
Evaluation & data	Can build evaluation sets, use data to drive iteration	Data engineering experience; designing human evaluation annotation systems
Paper reading	Can read and reproduce recent papers	Top-tier conference papers / open-source model contributions

Learn to spot "fake barriers" in LLM role JDs

LLM role JDs often read the most "intimidating" (RLHF, thousand-GPU training, Agent frameworks), but close inspection reveals most are nice-to-haves. The real distribution is: pre-training roles genuinely require large-scale training experience (mainly senior PhDs or experienced engineers), while application/deployment roles only need "can use models + can evaluate + can engineer." The skill requirements between these two categories differ enormously, and applying to the wrong direction is the most common waste. How to judge: look at the organizational unit—research institute / foundation model team vs. business tech team. The former needs training capability; the latter needs application capability.

3. NLP Algorithm Engineer

After the LLM boom, NLP roles haven't disappeared—they've clearly evolved toward "LLM + domain knowledge." Representative JDs fall into two categories:

• General NLP / language understanding (search engines, intelligent customer service, content understanding): Classification, extraction, matching, summarization.
• LLM application track (knowledge base Q&A, Agents, content generation): Retrieval augmentation, tool calling, long-context processing.

Skill requirement breakdown (commonalities across two representative JDs):

Dimension	Hard Requirements (almost always present)	Nice-to-Haves (high frequency)
Programming	Python; data processing capability	C++/Java; service development
Models	Familiar with pre-trained language models and mainstream paradigms	Fine-tuning and alignment techniques; full RAG pipeline
Deep learning	Deep understanding of Transformer and attention mechanisms	Experience reading training framework source code
Engineering	Text data cleaning, annotation, and evaluation workflows	Vector search (faiss, etc.); Agent frameworks
Business/domain	Ability to map business metrics to model metrics	Search/customer service/content domain experience

4. CV Algorithm Engineer

Computer vision roles went through two changes in the LLM era: traditional tasks (detection, segmentation, OCR) remain industrial necessities, and multimodal LLMs are causing CV engineers' skill stacks to overlap with LLMs. Representative JDs fall into two categories:

• Perception / traditional task track (autonomous driving, content safety, OCR, security): Detection, segmentation, recognition, emphasizing accuracy and deployment.
• Multimodal track (text-to-image, image-to-text, visual Q&A): Visual encoders + large model alignment.

Skill requirement breakdown (commonalities across two representative JDs):

Dimension	Hard Requirements (almost always present)	Nice-to-Haves (high frequency)
Programming	Python; proficient in DL frameworks	C++; inference engines (TensorRT/ONNX)
Vision fundamentals	Familiar with mainstream detection/segmentation/classification models	Hands-on object detection projects; data augmentation and long-tail handling
Deep learning	Training and tuning experience; model compression and deployment	Multimodal models (CLIP-like) experience; large model fine-tuning
Data	Data collection, cleaning, and annotation workflows	Semi-supervised/self-supervised methods; evaluation set design

5. Recommendation Algorithm Engineer

A perennial role across e-commerce, content, and advertising—the largest single category within the "Algorithm Engineer" roles domestically. Representative JDs fall into two categories:

• Recall / ranking / re-ranking (e-commerce, short video, news feed): CTR/CVR prediction, vector recall, multi-objective optimization.
• Engineering track (recommendation platforms): Feature platforms, training platforms, online inference services.

Skill requirement breakdown (commonalities across two representative JDs):

Dimension	Hard Requirements (almost always present)	Nice-to-Haves (high frequency)
Programming	Python; quality engineering code	C++/Java; high-concurrency online service experience
Algorithms	ML fundamentals; CTR/CVR prediction models	Deep recall (two-tower/graph recall); multi-objective modeling
Engineering	Feature engineering and offline/online consistency	Feature platform/training platform construction experience; big data tools
Data structures & algorithms	Written tests and online system design	High-concurrency scenario design experience

A hidden requirement for recommendation roles: metric awareness

JDs for recommendation roles rarely list "understanding business metrics" as a hard requirement, but it's actually an implicit divider in interviews: what does a 0.5-point AUC increase mean? Longer user session time or hurting gross margins? Interviewers use such questions to separate "can run models" from "can do recommendation." Prep for this capability by revisiting the section on metric design in Interview Questions.

6. ML Platform / MLOps Engineer

As models multiply, training and deployment themselves become roles. Representative JDs fall into two categories:

• Training platform track: Distributed training scheduling, resource management, experiment management.
• Inference / online serving track: Model serving, auto-scaling, canary releases, monitoring and alerting.

Skill requirement breakdown (commonalities across two representative JDs):

Dimension	Hard Requirements (almost always present)	Nice-to-Haves (high frequency)
Programming	Python and at least one systems language	Go; Kubernetes and container orchestration
ML fundamentals	Understand model training and inference pipelines	Mastery of common model lifecycle management
Engineering	CI/CD, monitoring, observability	GPU resource management and scheduling; inference engines
Distributed systems	Distributed systems principles (consistency/scheduling/fault tolerance)	Large-cluster operations experience; cloud-native

This role is the best practical carrier for understanding MLOps, and a classic pathway for algorithm engineers transitioning to engineering.

3. Overseas Company Roles

Overseas JDs use very different wording from domestic ones, but the skill core is highly similar. Below are English JD commonalities for six common role types across six companies.

1. Google: SWE-ML / ML Engineer / Research Scientist

Google's ML roles fall heavily under the Software Engineer tag (SWE-ML), emphasizing "engineering over research."

• Common requirements: Strong programming skills (Python/C++); solid ML fundamentals; experience with distributed systems and production ML; for research roles, publications in top venues.
• Signal reading: SWE-ML means the interview body is system design + coding, with ML depth present but limited in proportion; Research Scientist directly requires publication records.

2. Meta: ML Engineer / Research Engineer / AI Engineer

Meta's ML Engineer is "applied research" oriented: read papers, but also turn them into production systems.

• Common requirements: Experience training large-scale models; PyTorch proficiency; strong C++/Python; understanding of ML infrastructure (data pipeline, training, serving).
• Signal reading: Meta is the home of PyTorch, so PyTorch appears extremely frequently in their JDs; Research Engineer sits between researcher and engineer, requiring "can reproduce papers and engineer them."

3. Amazon: Applied Scientist / ML Engineer / SDE-ML

Amazon's role spectrum is the most layered: Applied Scientist (modeling and scientific methods), ML Engineer (systems and pipelines), SDE-ML (software engineering + ML specialization).

• Common requirements: Strong ML fundamentals and statistics; hands-on experience with modeling (LLMs, recommender systems); proficiency in Python and SQL; experience with AWS stack; strong communication for science roles.
• Signal reading: Amazon places significantly higher emphasis on statistical foundations and experimental design (A/B testing) than other companies, consistent with its e-commerce + cloud business DNA; SQL also appears more frequently in Amazon JDs than peers.

4. OpenAI / Anthropic: ML Engineer / Research Engineer / Applied AI

Frontier lab roles are few and highly selective, but their JD patterns are very clear: either research (pretraining / alignment / scaling) or infrastructure (training infra / inference infra).

• Common requirements: Deep expertise in deep learning and large-scale training; experience with distributed training frameworks (PyTorch, JAX); strong systems engineering for infra roles; for research roles, a track record of original contributions.
• Signal reading: These JDs have almost no "business-facing" roles—all revolve around the model itself. JAX, distributed training, and infra are keywords. For most candidates, these are industry wind vanes rather than realistic targets—their skill lists will permeate all major company JDs within a year or two.

5. Microsoft: Applied Scientist / ML Engineer

Microsoft's roles span Research, Cloud (Azure AI), and Product (Copilot-related).

• Common requirements: ML/deep learning fundamentals; experience with LLM application development (RAG, fine-tuning, evaluation); production ML experience; Python and C#/C++.
• Signal reading: Microsoft's JDs are among the earliest and most intensive adopters of "LLM application skills." Terms like RAG, evaluation, and AI safety appear in Microsoft JDs earlier than at most other companies.

Quick Reference: English JD Keywords

Keyword	Common Meaning	Domestic Equivalent
ML fundamentals	ML foundations: modeling, evaluation, bias-variance	Solid ML foundations
Deep learning	DL: neural networks, training, and tuning	Proficient in DL frameworks
Distributed training	Distributed training: data/model parallelism	Large-scale training experience
LLM application	LLM applications: RAG, fine-tuning, Agents	LLM deployment experience
MLOps / ML infra	Model lifecycle and infrastructure	Model platform / engineering
Production experience	Evidence of production deployment	Engineering capability to deploy
Publications	Paper publications	Research capability proof

"Translation ability" for overseas applications

The same capability is written completely differently in Chinese and English JDs. A Chinese JD writes "familiar with mainstream LLM application paradigms"; an English JD writes experience building RAG-based applications. A Chinese JD writes "solid engineering skills"; an English JD writes owned production systems end-to-end. Before applying overseas, first translate your project experience into the English JD's "verb + result" structure—this is the core technique from Resume Analysis applied to cross-language scenarios.

4. Skill Word Frequency Table

The table below extracts high-frequency skill words from common domestic and overseas JDs above (including samples synthesized in Sections 2 and 3), ordered by empirical frequency. This is not a precise statistic but a magnitude judgment from reading many JDs—the top two tiers appear in virtually all JDs, while the lower two vary by role.

Rank	Skill Word	Frequency Tier	Where It Appears
1	Python	★★★★★ Almost always present	Language threshold for all algorithm/ML roles
2	ML (foundations)	★★★★★ Almost always present	First requirement for all modeling roles
3	Deep learning	★★★★☆ High frequency	Standard for modeling roles; medium for platform roles
4	Data structures & algorithms	★★★★☆ High frequency	Hard threshold for written tests and interviews
5	PyTorch	★★★★☆ High frequency	De facto standard for DL and LLM roles
6	SQL	★★★☆☆ Medium frequency	Common for data roles and business modeling roles
7	Distributed	★★★☆☆ Medium frequency	Training/platform/serving roles
8	LLM	★★★☆☆ Medium but fastest rising	Diffused to virtually all algorithm roles post-2024
9	RAG	★★☆☆☆ Emerging	Standard nice-to-have for LLM application roles
10	Fine-tuning (SFT/LoRA/RLHF)	★★☆☆☆ Emerging	LLM application and pre-training roles

Three readings worth noting:

1. Python is the only word that "appears across all roles without exception," whether algorithm, platform, data, or researcher roles. It's not just a language—it's shorthand for an ecosystem: PyTorch, NumPy, pandas, LangChain all live in Python.
2. LLM / RAG / fine-tuning are the only group showing "upward trend." Other words are basically stable; these three have risen from "appearing in a tiny fraction of roles" in 2023 to "standard background for algorithm roles" in 2026.
3. SQL is systematically underestimated. It appears in roughly half of all JDs, but because it's treated as a "default skill," job seekers often overlook it—yet in practice, querying, analyzing, and verifying production data all depend on it.

5. Mapping Table: Skill Words to Pages on This Site

Map the high-frequency words from the frequency table to pages on this site, and you have your "plug-the-gaps" navigation:

High-Frequency Skill Word	Actual Requirement in Roles	Page on This Site	How to Use
Python	Can write engineering-grade Python, not just scripts	Learning Paths and Glossary	Look up concept definitions; fill fundamentals along the path
ML (foundations)	Can clearly explain supervised/unsupervised/evaluation/feature engineering	Supervised Learning	Start with supervised learning, then expand
Deep learning	Can call frameworks, explain principles, justify tuning	Deep Learning Foundations	Fill neural networks and backpropagation
Data structures & algorithms	Written tests and hand-coding	Interview Questions	Review high-frequency check points before practicing problems
PyTorch	Can train, debug, and deploy models	Deep Learning Foundations	After learning concepts, run the framework
SQL	Query, clean, verify metrics	Learning Paths	Find the data processing section in the path
Distributed	Engineering capability for large-scale training/inference	MLOps	Fill model lifecycle and training engineering
LLM	Understand principles, apply, evaluate	Large Language Models	Build a big-picture understanding
RAG	Full retrieval-augmented pipeline	Large Language Models	See RAG engineering deployment
Fine-tuning	SFT/LoRA/alignment	Large Language Models	Learn fine-tuning and evaluation methodology

A single table can't capture the gap—go to the Skill Map

The mapping table only covers "word → page," not "you → word." Put each high-frequency word from this article into the Skill Map and mark it "Know / Don't Know / Partially Know" to get a true study gap list that's yours. JDs tell you what's needed; the Skill Map tells you what's missing—both steps are essential.

6. Trend Observations

1. LLM-Related Roles Are Increasing in Share

Using this rough metric—"the share of algorithm roles whose JDs mention LLM keywords (LLM / large model / generative / RAG / fine-tuning)":

2021  ~ 5%   (GPT-3 just appeared, only in research roles)
2023  ~ 20%  (Rapid spread after ChatGPT)
2025  ~ 50%  (General algorithm roles start requiring LLM capability)
2026  ~ 60%+ (LLM has become the default background for algorithm roles)

Basis: publicly visible trends from company career websites and job platform descriptions.
Not a precise statistic—only indicates magnitude and direction.

Two notable details in this trend:

• It's an overlay, not a replacement. "Knows LLM" rarely exists as a standalone role; most roles are "original role capability + LLM capability." Recommendation algorithm engineers are now expected to know RAG retrieval augmentation, CV engineers are expected to understand multimodal, NLP roles have almost entirely migrated to the LLM paradigm—traditional skills haven't disappeared; they've just gained a layer.
• Pre-training roles and application roles are diverging. The main force driving the share increase is application roles (using models), not pre-training roles (training models). The former has lower barriers, more openings, and faster growth; the latter has fewer roles, higher requirements, and is concentrated in a few teams.

2. Evolution Directions for Traditional ML Roles

Traditional modeling roles (risk control, recommendation, advertising, search) haven't shrunk, but they're evolving in three directions:

Evolution Direction	Manifestation	Meaning for Job Seekers
LLM-ization	Tree model era persists, but LLMs begin handling feature extraction, content understanding, and ranking assistance	Don't abandon traditional ML fundamentals, but develop the mindset of "combining them with LLMs"
Platformization	Business-line algorithm roles decrease; capability converges to platform teams	Pure business modeling roles are declining; platform and infrastructure roles are growing
Data/evaluation-focused	The bottleneck for LLM applications shifts from "building models" to "building data and doing evaluation"	Data engineering and evaluation capability become new scarce skills

A structural insight worth remembering

In the LLM era, the models themselves are becoming infrastructure (like electricity and water, charged by call), while data, evaluation, and scenario adaptation become the sources of differentiation. This explains two things: why platform/MLOps roles are increasing, and why "knows how to build evaluation sets, knows how to clean data" continues to gain weight in LLM JDs. These two blocks are exactly the core of MLOps and Large Language Models.

3. Three Pragmatic Recommendations for Job Seekers

1. Keep traditional fundamentals sharp. LLM roles are increasing, but interviews still test data structures, ML foundations, and Python—these are the common denominator across all roles and your anchor against role volatility.
2. Fill LLM capability as a "second skill." You don't need to train a trillion-parameter model, but "using an API / open-source model to build a RAG or Agent application and evaluate it" has become a standard interview question for algorithm roles in 2026, and deserves a full project.
3. Make decisions based on data, not emotion. Every quarter, refresh your reading of this article: go to job boards, pull the 20 most recent JDs for your target roles, and deconstruct them using the "hard/nice-to-have" framework from Section 1. JDs are signals from the market; you just need to learn how to decode them.

7. Further Reading

• Module Guide & Role Landscape —— Full panorama of nine role types; position yourself before filling gaps
• Skill Map —— Turn JD skill words into a personal study gap list
• Resume Analysis —— Rewrite project descriptions from the interviewer's perspective, tell the story the interviewer wants to hear
• Interview Questions —— High-frequency questions and answer frameworks; self-test last
• Job Search Sprint Plan —— The complete main thread of reverse-learning from JDs and interview questions
• Supervised Learning, Deep Learning Foundations —— The two hardest skill foundations
• MLOps —— Engineering capability from model to system
• Large Language Models —— LLM principles, RAG, and fine-tuning full picture
• Glossary —— Unified terminology to avoid "partially know" understanding

References

The following are reliable channels for obtaining real JDs. All syntheses in this article are based on publicly available information from these channels—company JDs are subject to real-time updates on official career pages; third-party platform information may be outdated:

• Domestic company official career pages: Alibaba (talent.alibaba.com), Tencent (careers.tencent.com), ByteDance (jobs.bytedance.com), Baidu (talent.baidu.com), Meituan (zhaopin.meituan.com), JD.com (zhaopin.jd.com)
• Overseas company official career pages: Google Careers (careers.google.com), Meta Careers (careers.meta.com), Amazon Jobs (amazon.jobs), OpenAI Careers (openai.com/careers), Anthropic Careers (anthropic.com/careers), Microsoft Careers (careers.microsoft.com)
• Domestic job platforms: Maimai (maimai.cn), BOSS Zhipin (zhipin.com), Liepin (liepin.com) — for observing role distribution and JD wording frequency
• Overseas salary and role statistics: levels.fyi — for understanding role types and compensation bands; unofficial data

A bottom line

This article does not provide or cite any verbatim "Company X's 2026 Role Y JD," because such content is both unverifiable and inevitably outdated. Always refer to JDs published in real time through official channels—treat every JD you read as training data, and this article merely teaches you how to read them.