I Made My ZZZ Code Site 100x Faster by Removing Flask

zenlesscodes — Wed, 04 Feb 2026 09:26:39 +0000

Remember that ZZZ code aggregator I built? Well, I looked at my VPS metrics and realized something dumb: I was running Python on every single request for data that updates once per hour.

So I ripped out Flask entirely. Here's what happened.

The Problem

My original setup was standard Flask + Gunicorn behind Nginx:

Request → Nginx → Gunicorn → Flask → Response

It worked fine. But the site was just... rendering the same JSON data every time. The codes only change when HoYoverse drops new ones (roughly weekly, sometimes monthly). Running a Python process for every visitor felt wasteful on a $3 VPS.

Memory usage hovered around 100MB. Not terrible, but not great either.

The Fix: Static File Generation

The new architecture is embarrassingly simple:

Request → Nginx → static file (HTML/JSON)

A background daemon generates static files every hour. Nginx serves them directly. That's it.

The key insight: if your data doesn't change between requests, don't compute it between requests.

The Code That Made It Work

Atomic File Writes

The trickiest part was ensuring users never see a half-written file. Linux gives us atomic renames, so:

def atomic_write(filepath: Path, content: str) -> None:
    temp_path = filepath.with_suffix(".tmp")
    try:
        temp_path.write_text(content, encoding="utf-8")
        temp_path.rename(filepath)  # Atomic on Linux
    except Exception as e:
        if temp_path.exists():
            temp_path.unlink()
        raise e

Write to a temp file, then rename. The rename is atomic - a reader either gets the old file or the new file, never a partial write.

Scheduler Config

APScheduler handles the hourly updates, but I needed to prevent overlapping runs if one takes too long:

scheduler.add_job(
    update_codes_task,
    "interval",
    minutes=60,
    max_instances=1,    # Prevent overlapping
    coalesce=True,      # Combine missed runs
)

max_instances=1 ensures only one update runs at a time. coalesce=True means if the server was down and missed 3 runs, it only runs once when it comes back up (not 3 times in a row).

The Results

Metric	Before (Flask)	After (Static)
Memory	~100MB	~20MB
Requests/sec	~100-500	~10,000+
Dependencies	flask, gunicorn	jinja2

That requests/sec number is from Nginx serving static files directly. Your mileage will vary based on file size and server specs, but the point is: it's way faster.

Bonus: Image Optimization

While I was at it, I converted all the reward icons from remote PNG URLs to self-hosted WebP files:

const ICON_MAP = {
  'Polychrome': '/static/e6ee639872c119aa6895758f3a755d3b.webp',
  'Denny': '/static/7db931d2138edcfb9e155907503f2fbe.webp',
  'Senior Investigator Log': '/static/ab0406e53b7f8c4afe08096a2f7aa587.webp',
  // ... 11 reward icons total
};

The annoying part? I was loading these from game8.co on every page view. Now they're:

25-34% smaller (WebP compression vs PNG)
Self-hosted (no external dependencies)
Content-hashed for cache-busting

I kept PNG fallbacks for older browsers, but modern browsers get the lighter WebP versions.

Unexpected Benefits

Crash-proof: If my Python daemon dies, the last-generated files keep getting served. Users see stale data (worst case: 1 hour old) instead of an error page.

Simpler deployment: No WSGI server to configure. Just run the Python script as a systemd service and point Nginx at a directory.

IndexNow integration: When codes actually change, I ping search engines. But it only happens when there's real new content, not on every request.

The Takeaway

The best optimization is often eliminating unnecessary work entirely.

Before: Run Python interpreter → load Flask → route request → fetch cached data → render template → return response.

After: Return file.

This pattern works whenever your data updates less frequently than your traffic. Blog posts, documentation sites, dashboards with hourly data - all good candidates.

Cost Breakdown

Still the same as before:

Domain: ~$10/year
VPS: ~$3/month
Cloudflare: Free tier

zenlesscodes.com - still aggregating ZZZ codes, now 100x faster at it.

How I Built a ZZZ Code Aggregator in a Weekend

zenlesscodes — Mon, 02 Feb 2026 06:39:35 +0000

I play Zenless Zone Zero, and like most gacha games, HoYoverse drops redemption codes for free currency. The annoying part? I kept missing codes.

So I built zenlesscodes.com - a simple aggregator that pulls from multiple sources and shows all active codes in one place.

The Stack

Nothing fancy:

Python/Flask for the backend
BeautifulSoup for scraping(respectfully) the Fandom wiki
APScheduler for hourly background updates
Gunicorn as the WSGI server
Runs on a $3/month VPS

How It Works

The site fetches codes from 3 sources every hour:

def fetch_all_codes():
    primary_codes = fetch_primary_api()      # hoyo-codes API
    github_codes = fetch_github()            # community GitHub list
    fandom_codes, expired = fetch_fandom()   # wiki scraping

    return aggregate_codes(primary_codes, github_codes, fandom_codes, expired)

The tricky part was deduplication and expiration detection. Different sources report the same codes with slightly different formatting, and the Fandom wiki is actually the most reliable for knowing when codes expire.

The Fandom Scraping

Fandom uses a MediaWiki backend, so instead of fighting Cloudflare, I just use their API:

def fetch_fandom_via_api():
    params = {
        "action": "parse",
        "page": "Redemption_Code",
        "format": "json",
        "prop": "text",
    }
    response = requests.get(FANDOM_API_URL, params=params)
    return response.json()["parse"]["text"]["*"]

Then I parse the HTML table, checking for bg-green (active) vs bg-red (expired) CSS classes on the status cells.

SEO Stuff

Threw in IndexNow pings so search engines know when content updates. It's literally one API call to Bing and they share it with the other search engines.

What I'd Do Differently

Honestly, not much. Flask might be overkill - this could probably be a static site generated by a cron job. But the Flask setup gives me a /api/codes endpoint for free, and the scheduling is cleaner.

Cost

Domain: ~$10/year
VPS: ~$3/month(Already had this, prepaid for 3 years)
Cloudflare: Free tier

That's it. Launched a couple days ago.

zenlesscodes.com if you play ZZZ and want to stop missing codes.

DEV Community: zenlesscodes