Apex Legends Season 29, nicknamed Overclocked, landed on May 5, 2026 with a new Legend, a reworked matchmaking test, and enough balance churn that last split’s tier list is already out of date. If you’ve bounced between three or four tier-list sites this week and gotten three or four different S-tier rosters, you’ve already found the real problem: most public tier lists are opinion, not data. This tutorial walks you through building your own Apex Legends Season 29 tier list from a repeatable scoring method, so you can update it in minutes every time Respawn ships a mid-season patch instead of waiting for a stranger’s spreadsheet to catch up. By the end you’ll have a working Python project that pulls in your own tracked stats, applies a weighted formula, and spits out a clean S-to-D tier table you can trust because you built it.
What Changed in Apex Legends Season 29: Overclocked
Overclocked shipped as Apex Legends’ 29th season, introducing the Legend Axle alongside a matchmaking experiment EA calls the “Overclocked Matchmaking Update.” According to EA’s official patch notes, later in the split solo players queuing in both Ranked and Unranked are matched against opponents sitting a slightly lower skill tier, a change aimed at narrowing the gap between solo queue and coordinated three-stacks. For a full breakdown of every tweak that shipped alongside it, IGN’s rundown of the Overclocked patch notes walks through each change in detail. That single tweak matters more for a tier list than it sounds, because a Legend that thrives against disorganized lobbies won’t necessarily hold up once matchmaking tightens back up for premades.
Ranked also got its usual split structure, with EA’s patch notes confirming a Ladder 1 event running May 14 to 17, 2026, early in the season. For Split 2, the ranked map rotation settled on Storm Point, World’s Edge, and E-District, a smaller pool than some past seasons and one that rewards Legends with strong rotation tools over pure third-party aggression. Any Apex Legends tier list built for Season 29 has to account for that map pool, because a Legend that dominates a vertical map like E-District can fall flat on the wide-open ridgelines of Storm Point.
None of this is static. Respawn pushed a mid-season update, Patch 29.1, that already adjusted Axle’s kit less than two months after launch. That’s the real argument for this tutorial: a tier list is a snapshot, and if your method can’t be re-run in five minutes after the next patch, it’s stale before you finish reading it.
This isn’t unique to Season 29. Every Apex Legends season since launch has followed roughly the same pattern: a big splash patch at season start, a quieter mid-split correction once Respawn sees real match data, and then smaller hotfixes as pros and high-rank streamers find the edge cases nobody tested internally. If you’ve only ever read a tier list someone else published once and never revisited it, you’ve effectively been playing on outdated information for most of the split without realizing it. Treating your tier list as a living document, not a one-time article, is the whole premise behind building your own.
Meet Axle: Abilities and Early Tier Impact
Axle is Season 29’s new Legend, classified as a Skirmisher, and her kit is built entirely around movement. Her passive, Drift, lets her accelerate and hold tighter lateral control while sliding, turning ordinary terrain into a speed boost. Her tactical, Nitro Gate, drops a speed gate on the ground; anyone who passes through it, friend or foe, gets pulled into a boosted slide with extra velocity and control that can last up to five seconds unless the player manually breaks out of it. Her ultimate, Kickstart, launches an autonomous, enemy-seeking drone that chases down opponents and launches them into the air on impact, according to EA’s official Legend reveal.
That combination made Axle an instant fixture near the top of most community tier lists. Sites including CarryLord, SkyCoach, and Two Average Gamers all list Axle alongside Octane, Conduit, and Lifeline in S-tier following the 29.1 patch, though they disagree on whether Alter or Mad Maggie rounds out that top group. The disagreement itself is useful data: when three separate trackers can’t agree on a fifth S-tier pick, that’s exactly the kind of borderline case a weighted scoring method resolves better than a gut-feel ranking.
Respawn moved quickly to rein Axle in. Per the official Overclocked Midseason Designer’s Notes, Patch 29.1 replaced Axle’s Level 2 upgrade, previously called Super Slider, with an upgrade that instead reduces her tactical cooldown and restores her maximum number of active Nitro Gates from two up to three. The same patch also closed an exploit that let knocked players slide an unintended distance while affected by Nitro Gate. Translation: Axle is still strong, but Respawn is actively tuning her, which is exactly why a static tier list written in May 2026 is worthless in October.
Beyond raw power, Axle’s role in a squad comp is worth separating out, because tier lists that only measure win rate can flatten this distinction. A Skirmisher built around speed gates functions less like a solo carry and more like a rotation enabler, pulling teammates through Nitro Gate alongside her toward a fight or away from a bad third party. That makes her value partly dependent on whether her squadmates actually use the gate, which is exactly the kind of context a raw win-rate number can’t capture on its own, and exactly why the utility-uptime column in the scoring method below matters as much as win rate itself.
Prerequisites: Tools, Data and Versions You’ll Need
You don’t need a game API key or any special Respawn access to build this project. Everything runs on data you collect yourself from publicly visible sources, processed locally. Here’s what to have installed before you start.
- Python 3.12 or newer — install from python.org or your package manager; the script below uses only f-strings and standard dataclasses, both stable since 3.7+.
- pandas — install the latest release with
pip install pandas; it handles the CSV loading, grouping, and sorting. - tabulate (optional) — install with
pip install tabulatefor prettier console output; the script falls back to pandas’ built-in printing if you skip it. - A text editor or IDE — VS Code, PyCharm, or even a plain terminal editor works fine.
- A spreadsheet or CSV file — where you’ll log pick rate, win rate, and kill participation numbers you track from your own matches or from public trackers like apexdb.gg’s patch notes archive.
That’s the whole stack. No cloud account, no paid API, no Discord bot hosting. The goal is a tier list you can regenerate on your laptop the night a new patch drops.
If you’d rather not log your own matches by hand, you can seed the CSV from aggregate numbers published by community trackers instead, then correct it with your own tracked games over time as your sample grows. The method doesn’t care where the numbers originate, only that you apply the same weighting formula consistently across every Legend. Mixing self-tracked data with community-sourced data is fine as long as you note which rows come from which source, since that helps you spot when a discrepancy is a real meta shift versus just a difference in how two sources define “win rate.”
| Detail | Season 29 Overclocked |
|---|---|
| Release date | May 5, 2026 |
| New Legend | Axle (Skirmisher) |
| Ranked Ladder 1 window | May 14–17, 2026 |
| Split 2 ranked map rotation | Storm Point, World’s Edge, E-District |
| Matchmaking change | Solo queue matched vs. slightly lower skill tier later in split |
| Major balance patch | 29.1 Midseason Designer’s Notes (Axle rework) |
Step 1–3: Collect the Inputs a Real Tier List Needs
Step 1: Decide which game mode you’re ranking for
The single biggest mistake in most Apex Legends tier lists is treating pubs and ranked as the same game. A Legend that excels in a 20-squad pubs lobby full of uncoordinated players often performs differently in ranked, where every squad is communicating and third-partying with intent. Pick one mode to rank for first. This tutorial assumes ranked, since that’s where most of Season 29’s matchmaking and map rotation changes actually bite. If you split your time between both modes, keep two entirely separate CSV files rather than one combined dataset, because merging them quietly dilutes exactly the signal you’re trying to isolate.
Step 2: Define your data schema
Before writing code, decide exactly which columns you’ll track. Keep it to metrics you can actually pull consistently from your own match history or from a tracker you trust. Here’s the schema this project uses, saved as a CSV file named legend_data.csv:
legend,role,pick_rate_pct,win_rate_pct,kill_participation,utility_uptime_pct
Axle,Skirmisher,18.4,24.1,2.3,55
Octane,Assault,14.2,19.8,2.6,70
Conduit,Support,12.9,21.5,1.8,80
Lifeline,Support,11.1,20.2,1.5,65
Mad Maggie,Assault,8.7,17.9,2.1,40
Wraith,Recon,16.0,18.4,2.0,60
Seer,Recon,7.2,16.1,1.9,45The numbers above are placeholder values to illustrate the format — swap them for the figures you actually track once you start logging matches or pulling from a tracker you trust. What matters is consistency: pick rate, win rate, kill participation, and utility uptime (how often a Legend’s tactical or ultimate is actually available and used) are enough signal to separate genuine standouts from hype picks.
Step 3: Cross-reference against official patch notes
Before you trust any number, check it against what actually changed. Read through EA’s official Overclocked patch notes and the 29.1 designer’s notes side by side with your data. If a Legend’s win rate jumped the same week their kit got buffed, that’s signal. If it jumped for no documented reason, that’s probably sample size noise, and you should weight it down or wait for more matches before trusting it. This step feels like busywork the first time you do it, but it’s what separates a tier list grounded in Respawn’s actual balance decisions from one that’s just chasing noisy streaks, and it only takes a few minutes once you’ve bookmarked the official patch notes page for the season.
Step 4–6: Build the Scoring Script
Step 4: Set up your project folder
Create a folder called apex-tier-builder, drop legend_data.csv inside it, and create an empty file named apex_tier_builder.py in the same directory. That’s your whole project structure for now. If you work across multiple Python projects, it’s worth creating a virtual environment first with python3 -m venv venv and activating it before installing pandas, so this project’s dependencies don’t collide with anything else on your machine.
Step 5: Write the composite scoring function
The core idea is a weighted sum. Win rate matters most because it’s the closest proxy to “does this Legend actually help you win,” but pick rate, kill participation, and utility uptime each catch something win rate alone misses, like whether a Legend is only winning because almost nobody plays them yet.
import pandas as pd
WEIGHTS = {
"win_rate_pct": 0.40,
"pick_rate_pct": 0.15,
"kill_participation": 0.25,
"utility_uptime_pct": 0.20,
}
def normalize(series):
return (series - series.min()) / (series.max() - series.min()) * 100
def compute_score(df):
df = df.copy()
for col in WEIGHTS:
df[f"{col}_norm"] = normalize(df[col])
df["composite_score"] = sum(
df[f"{col}_norm"] * weight for col, weight in WEIGHTS.items()
)
return df.sort_values("composite_score", ascending=False)Normalizing each column to a 0–100 scale before weighting matters a lot here. Raw win rates cluster between roughly 15% and 25%, while utility uptime can swing from 40% to 80%. Without normalization, the column with the widest raw range quietly dominates the score regardless of the weight you assigned it.
Step 6: Test the scoring function on your sample data
Load your CSV and run the function to make sure it produces a sane ordering before you build the tier-bucketing logic on top of it.
df = pd.read_csv("legend_data.csv")
scored = compute_score(df)
print(scored[["legend", "composite_score"]])If the top of your list looks obviously wrong (say, a Legend with a tiny pick rate sitting at number one purely because of a lucky small sample), that’s your cue to either collect more matches or add a minimum-sample-size filter before trusting the output.
Step 7–9: Turn Scores Into Tiers
Step 7: Choose your tier thresholds
With composite scores normalized to 0–100, you can set fixed cutoffs rather than arbitrary top-N slicing. This keeps your Apex Legends tier list stable even as the exact number of Legends per tier shifts from patch to patch.
| Tier | Composite score range | What it means |
|---|---|---|
| S | 80–100 | Clear pick for ranked, strong across both solo and squad play |
| A | 65–79 | Reliable, situational edge depending on map or squad comp |
| B | 50–64 | Viable but requires coordination to shine |
| C | 35–49 | Niche, needs a specific team comp or map to work |
| D | Below 35 | Struggles against current meta and map pool |
Step 8: Write the bucketing function
def assign_tier(score):
if score >= 80:
return "S"
elif score >= 65:
return "A"
elif score >= 50:
return "B"
elif score >= 35:
return "C"
else:
return "D"
def build_tier_list(df):
scored = compute_score(df)
scored["tier"] = scored["composite_score"].apply(assign_tier)
return scored[["legend", "role", "composite_score", "tier"]]Step 9: Sanity-check against community tier lists
Run your output next to a couple of public trackers, like Dexerto’s Legend tier list wiki. You’re not trying to match them exactly; you’re checking for wild outliers. If your method puts a Legend in D-tier that every public list has in A-tier, go back and check whether your sample size for that Legend is simply too small, or whether one of your weighted columns is being skewed by a handful of unusual matches. It’s also worth checking the date a public tier list was last updated. A tracker that hasn’t touched its rankings since before Patch 29.1 is comparing apples to oranges with your freshly scored data, and that gap alone explains a lot of the disagreement you’ll see between sites.
Step 10–12: Automate, Validate and Publish
Step 10: Print a clean output table
from tabulate import tabulate
def print_tier_list(df):
grouped = df.sort_values("composite_score", ascending=False)
print(tabulate(grouped, headers="keys", tablefmt="github", showindex=False))
if __name__ == "__main__":
data = pd.read_csv("legend_data.csv")
tier_list = build_tier_list(data)
print_tier_list(tier_list)Step 11: Automate the refresh
Patches land mid-split, not just at season launch, so set a reminder to re-run the script rather than rebuilding your tier list from scratch by hand. A simple cron entry on macOS or Linux, or a Scheduled Task on Windows, can even email you the output after you update the CSV.
# crontab entry: re-run every Monday at 9am to catch weekend patch notes
0 9 * * 1 cd /path/to/apex-tier-builder && python3 apex_tier_builder.py >> tier_log.txtStep 12: Export and version your results
Save each run’s output with the patch number in the filename, like tier_list_29_1.csv, so you can track how individual Legends moved between patches. That history is more useful than any single snapshot, because it shows you whether a Legend’s rise was a real buff or a two-week statistical blip. If you want to share the result with a squad or a Discord server, exporting to CSV also means it opens cleanly in Google Sheets or Excel for anyone who’d rather read a spreadsheet than run Python themselves, without you having to rebuild the formatting by hand each time.
tier_list.to_csv(f"tier_list_29_1.csv", index=False)Sample Output: A Season 29 Overclocked Tier Table
Running the full script against the placeholder data from Step 2 produces output like this in your terminal:
| legend | role | composite_score | tier |
|-------------|-----------|--------------------|--------|
| Conduit | Support | 84.62 | S |
| Axle | Skirmisher| 81.07 | S |
| Octane | Assault | 74.33 | A |
| Lifeline | Support | 68.91 | A |
| Wraith | Recon | 52.44 | B |
| Mad Maggie | Assault | 41.18 | C |
| Seer | Recon | 33.76 | D |Notice Conduit edges out Axle here even though Axle got more hype at launch — that’s the utility-uptime weighting doing its job, since Conduit’s kit is available far more often per fight. Your own numbers will shift this table once you plug in real tracked data, which is exactly the point: this Apex Legends tier list is yours, not a copy of whatever a content site published in May.
Pay attention to the gap between tiers, not just the ranking order. Conduit and Axle sit close together at the top of this sample output, which tells you they’re roughly interchangeable picks rather than one being a clear step above the other. Wraith, by contrast, sits more than fifteen points below Lifeline despite being a long-time staple of the roster, which in a real dataset would be worth double-checking against her actual match count before you accept it. A gap that wide between B-tier and A-tier is usually either a genuine power difference or a sign that something in the input data needs a second look.
How Patch 29.1 Reshuffled the Rankings
The clearest documented example of why a static tier list fails is Axle herself. At launch, her kit leaned on a Level 2 upgrade called Super Slider. By the 29.1 midseason patch, Respawn had already swapped that upgrade out for a Nitro Gate cooldown reduction and an increase in max active gates from two to three, according to the official designer’s notes. That’s not a cosmetic tweak — it changes how many escape or engage windows an Axle player gets per fight, which directly moves her win rate and utility uptime numbers in any tier-list formula.
The same patch also fixed an exploit where knocked players affected by Nitro Gate could slide an unintended distance, effectively giving squads a free extraction tool. Closing that bug likely pulled Axle’s effectiveness back down slightly in high-level play, even though her raw ability kit on paper looks unchanged to a casual reader of the patch notes. This is exactly the kind of change a scoring method built on tracked win rate and utility uptime catches automatically, while a tier list written once at season launch simply misses it.
It’s also why public tier lists disagree so much right now. CarryLord, SkyCoach, Epiccarry, and Two Average Gamers all published Season 29 rankings, and while they broadly agree on the top four or five names, they split on where to place Legends like Seer, who some trackers list in A-tier for recon value and others drop to C-tier for having a weak kit against the current map rotation. That split isn’t a mistake on anyone’s part — it reflects different weighting choices, different sample windows, and in some cases data collected before versus after 29.1 shipped.
There’s also a recognizable pattern to how Respawn times these changes. New Legends tend to launch strong enough to drive adoption and give players a reason to try the season’s headline feature, then get quietly trimmed once enough high-rank data comes in to justify a correction without feeling like a punishment to players who just picked them up. Axle’s 29.1 adjustment fits that pattern closely: strong enough at launch to dominate early tier lists, then brought back toward the pack once the data caught up. Recognizing that cycle means you can expect a similar correction for any new Legend Respawn ships in future seasons, and build a small buffer into your early-season scoring rather than treating week-one numbers as gospel.
Weapon Meta and Ranked Map Rotation: Context That Changes Tiers
A Legend tier list doesn’t exist in a vacuum separate from the gun meta or the map pool, and Season 29’s Split 2 ranked rotation of Storm Point, World’s Edge, and E-District changes which kits actually get used. Legends built around fast rotations and third-party setups, like Octane and Wraith, tend to score higher on wider maps like Storm Point, where distance between fights rewards mobility. Legends leaning on close-quarters utility, like Conduit’s shield regeneration zones, tend to hold up better on tighter maps like E-District.
If you’re building a tier list meant to last the whole split rather than just this week, weight your kill participation and win rate columns separately by map when you have enough data, rather than averaging them across the whole rotation. A Legend that’s elite on two of three ranked maps and mediocre on the third will often land in the same B-tier bucket as a Legend that’s consistently average everywhere, which hides useful information from whoever reads your table.
Weapon balance changes matter too, since a Legend whose kit synergizes with a specific weapon class (Rampart’s wall and LMG affinity is the classic example) rises and falls with that weapon’s standing in the meta. Before finalizing any patch’s tier list, check the official Overclocked patch notes and apexdb.gg’s season-by-season patch archive for weapon-specific changes, and flag any Legend whose score moved mainly because the guns around them changed rather than their own kit.
Be careful not to overcorrect here, though. It’s tempting to credit every win-rate swing to a weapon meta shift, but plenty of movement in a Legend’s numbers each week is just normal variance from a few hundred matches, not a structural change. A reasonable rule of thumb: if a Legend’s score moves more than a handful of points in a single week with no corresponding entry in the official patch notes, treat it as noise until a second week of data confirms the trend, rather than rewriting your tier list on a single data point.
Common Pitfalls When Building an Apex Legends Tier List
Most tier lists go wrong in a handful of predictable ways. Watch for these when you’re building your own.
- Mixing pubs and ranked data. A Legend’s pub win rate and ranked win rate can diverge sharply because pubs include uncoordinated squads and casual players testing new Legends. Keep your dataset filtered to one mode.
- Ignoring sample size. A Legend with a 5% pick rate and a flashy win rate over 40 matches isn’t statistically meaningful yet. Set a minimum match count before trusting any row.
- Skipping normalization. Feeding raw, unscaled metrics straight into a weighted sum lets whichever column has the widest numeric range silently dominate your score, regardless of the weight you assigned it.
- Treating patch notes as optional reading. If you don’t cross-reference your data against official patch notes, you can’t tell whether a score shift is a real balance change or random variance.
- Copying someone else’s weights without understanding them. A weighting scheme built for a pubs-focused tier list won’t produce a useful ranked tier list, and vice versa.
- Never re-running the method. The entire point of building a repeatable script instead of a one-off spreadsheet is to re-run it after every patch. A tier list that never gets refreshed is worse than no tier list at all, because it looks authoritative while being wrong.
- Overfitting to one squad’s playstyle. If all your tracked matches come from the same two friends you duo with constantly, your data reflects their comp preferences more than the broader meta. Pull in data from a few different squads or lobbies if you can, or at least note the limitation when you share your results.
Troubleshooting Guide
Here are the issues you’re most likely to hit while running this project, and how to fix each one.
| Problem | Likely cause | Fix |
|---|---|---|
| ModuleNotFoundError: pandas | pandas isn’t installed in your active Python environment | Run pip install pandas in the same terminal/environment you’re running the script from |
| Script runs but tabulate import fails | tabulate is optional and wasn’t installed | Either run pip install tabulate or delete the tabulate import and use print(df) instead |
| All composite scores come out as NaN | A column in the CSV has a missing or non-numeric value | Open the CSV and check for blank cells or stray text in numeric columns; fill gaps with 0 or drop the row |
| Every Legend lands in the same tier | Normalization is dividing by zero because a column has no variance (all values identical) | Check that column for data-entry errors; if it’s genuinely flat, drop it from the weights temporarily |
| Legend names don’t match between CSV and public trackers | Different sites abbreviate or spell Legend names differently | Standardize on official in-game spelling, including capitalization, across every data source you merge |
| Scores shift wildly between two small updates | Sample size per Legend is too small to be stable | Add a minimum-matches filter and exclude Legends below that threshold from ranked tiers until you have more data |
| Script output doesn’t match this tutorial’s example | You’re using your own real data, not the placeholder values | This is expected and correct — your tier list should reflect your own tracked numbers, not the tutorial’s sample |
| Cron job never runs | Wrong working directory or Python path in the crontab entry | Use absolute paths for both the project folder and the python3 executable in the cron line |
Advanced Tips for Competitive-Grade Tier Lists
Once the basic script is working, a few upgrades make the output genuinely useful for ranked grinding rather than just a curiosity project. First, split your weights by rank bracket if you can gather the data, since a Legend’s effectiveness in Gold lobbies often looks very different from Diamond and Master lobbies where rotations and third-partying are far more disciplined.
Second, add a map-specific override layer on top of the base composite score, since Season 29’s three-map ranked rotation (Storm Point, World’s Edge, E-District) means a single average score can hide meaningful per-map swings, as covered above. A simple approach is to compute three separate composite scores, one per map, and average them with a note on variance rather than silently collapsing them into one number.
Third, track confidence alongside score. A Legend sitting at a composite score of 78 off 40 tracked matches should be flagged differently from one sitting at 78 off 400 matches, even though both show the same number. Adding a simple sample-size column next to your tier output keeps you honest about which rankings are solid and which are still noisy.
Finally, keep a changelog. Every time you re-run the script after a patch, note which Legends moved tiers and cross-reference that against the official patch notes for that update. Over a season or two, that changelog becomes a genuinely useful record of how Respawn’s balance philosophy evolves, and it’s the kind of thing that separates a one-off tier list from an ongoing tracking project.
One more upgrade worth the effort: weight recent matches more heavily than older ones instead of averaging your whole season’s data evenly. A simple way to do this without much extra code is to apply a decay factor based on match date, so a game played yesterday counts more toward a Legend’s current score than one played in week one of the split. This keeps your tier list responsive to the actual current meta rather than smoothing everything into an average that’s partly describing a patch that no longer exists.
The Complete Project: Full Script
Here’s the entire project assembled into one file. Save this as apex_tier_builder.py alongside your legend_data.csv, and you have a complete, working Apex Legends Season 29 tier list builder you can re-run after every patch.
import pandas as pd
from tabulate import tabulate
WEIGHTS = {
"win_rate_pct": 0.40,
"pick_rate_pct": 0.15,
"kill_participation": 0.25,
"utility_uptime_pct": 0.20,
}
def normalize(series):
return (series - series.min()) / (series.max() - series.min()) * 100
def compute_score(df):
df = df.copy()
for col in WEIGHTS:
df[f"{col}_norm"] = normalize(df[col])
df["composite_score"] = sum(
df[f"{col}_norm"] * weight for col, weight in WEIGHTS.items()
)
return df.sort_values("composite_score", ascending=False)
def assign_tier(score):
if score >= 80:
return "S"
elif score >= 65:
return "A"
elif score >= 50:
return "B"
elif score >= 35:
return "C"
else:
return "D"
def build_tier_list(df):
scored = compute_score(df)
scored["tier"] = scored["composite_score"].apply(assign_tier)
return scored[["legend", "role", "composite_score", "tier"]]
def print_tier_list(df):
grouped = df.sort_values("composite_score", ascending=False)
print(tabulate(grouped, headers="keys", tablefmt="github", showindex=False))
if __name__ == "__main__":
data = pd.read_csv("legend_data.csv")
tier_list = build_tier_list(data)
print_tier_list(tier_list)
tier_list.to_csv("tier_list_29_1.csv", index=False)That’s a complete, self-contained tool. Swap in your own tracked numbers in the CSV, adjust the weights to match what you personally value in ranked (maybe you weight kill participation higher if you play aggressively), and re-run it after every patch. Twelve steps, one script, and an Apex Legends tier list that updates as fast as Respawn does.
Frequently Asked Questions
What is the best Legend in Apex Legends Season 29 Overclocked?
Community trackers including CarryLord, SkyCoach, and Two Average Gamers broadly agree that Axle, Octane, Conduit, and Lifeline sit near the top following Patch 29.1, though exact ordering varies by site and by whether the data was collected before or after the midseason patch.
Is Axle good in ranked after the 29.1 patch?
Axle remains a strong pick, but Patch 29.1 scaled back her Level 2 upgrade path and closed a knockdown-sliding exploit, according to EA’s official designer’s notes, so her raw power is more measured than at launch.
How often should I update my Apex Legends tier list?
Re-run your scoring script every time Respawn ships a patch, including mid-season updates like 29.1. Checking the official patch notes first tells you whether a rerun is likely to move anything meaningfully.
Do pub tier lists and ranked tier lists need to be different?
Yes. Pick rate and win rate behave differently in pubs, where squads are often uncoordinated, versus ranked, where every squad is communicating. Keep separate datasets for each mode rather than averaging them together.
What changed in Apex Legends patch 29.1?
The 29.1 midseason patch primarily reworked Axle, swapping her Super Slider upgrade for a tactical cooldown reduction and an increase in max active Nitro Gates from two to three, while also fixing a knocked-player sliding exploit, per EA’s official patch notes.
Can I use this scoring method for weapons instead of Legends?
Yes. Swap the column names for weapon-relevant metrics like time-to-kill, recoil control, and ammo economy, and the same normalize-then-weight approach works for a weapon tier list.
Where can I find official Apex Legends patch notes?
EA publishes official patch notes and designer’s notes directly on ea.com, and apexdb.gg maintains an archive of patch notes organized by season for historical reference.
Why do different tier list sites disagree so much on Season 29?
Different sites collect data over different windows, weight metrics differently, and some published before Patch 29.1 while others updated after. Building your own scoring method, as covered in this tutorial, is the most reliable way to cut through that noise.