How to Publish a UEFN Island on Fortnite: A Beginner's Guide

You finished building your UEFN island, so the hard part should be over. For a lot of first-time creators, it isn't — publishing is where they get stuck. Not because the map is bad, but because publishing isn't one button. It runs across UEFN, the Fortnite Creator Portal, an age-rating questionnaire, and a moderation queue, and most guides only cover a slice of it.

This guide walks the whole path, in order, with the real blockers flagged along the way.

If you searched how to publish a Fortnite map, you're in the right place — but this is the UEFN flow, not the old in-game Creative-only one. The two are different, and mixing them up is the first mistake. Here's the clean version of how to publish your UEFN island, start to finish.

Quick answer: how to publish a UEFN island

To publish a UEFN island, enroll in the Fortnite Developer Program, get your project publish-ready, then run a memory calculation in UEFN to upload a private version. From there you finish everything in the Creator Portal — metadata, media, IARC rating, attributions, visibility — and submit for moderation.

Here's the full path at a glance:

Sort out your account — age, 2FA, and enrollment in the Fortnite Developer Program.
Get the project publish-ready — clean Verse, memory budget, cross-platform play, no risky audio.
Cook and upload from UEFN — launch a session, end it, let the memory calculation run, upload a private version.
Open the project in the Creator Portal — this is where publishing actually happens.
Build the release package — metadata, thumbnail and media, IARC questionnaire, attributions.
Set visibility and submit — choose Public, Unlisted, or Private, then submit for review.
Wait for the verdict — approved islands get a public code like 1234-5678-9012.

The one thing to burn into memory before anything else: UEFN does not publish your island. It uploads a private version. The Creator Portal is where the release gets finished.

Before you can publish: account eligibility and the Fortnite Developer Program

Before your island can be published, your Epic account has to clear a setup gate that has nothing to do with how good your map is. This is where beginners lose the most time — polishing the island for days while the real blocker sits in their account settings.

Start with the baseline. To publish a UEFN island you need to be 18 or older, have 2FA enabled on your Epic account, and have had your Fortnite account connected for at least 30 days. You also need to have actively edited in UEFN or Creative on at least 7 days. Miss one of these and the publishing path simply won't open.

Then comes enrollment. Publishing runs through the Fortnite Developer Program — sign up at create.fortnite.com/enroll. Older videos may call this the "Island Creator Program"; it's the same general path, just renamed. Enrollment is where you set your Creator Code, complete a tax interview, and connect a payout account through Hyperwallet. If you're outside the US, the tax interview usually means a W-8BEN form — that's normal, not a UEFN bug.

Here's the part worth underlining: you can technically publish without finishing the payment setup, but you'll never get paid. For a throwaway test island, fine. For anything you actually care about, do the account side first.

Do this first. The account and tax setup can take a few days to clear. Starting it the night before you want to launch is the classic beginner mistake.

Step 1 — Get your UEFN project publish-ready

A UEFN project is publish-ready when it compiles cleanly, stays inside the memory budget, plays correctly start to finish, works across platforms, and carries no obvious content risks. Most first submissions fail right here — before the island's actual idea ever gets judged.

Start with Verse. Your project should compile with no errors and no deprecation warnings. The publishing flow is the wrong place to discover a broken script, so fix the logic and confirm the core loop still works after your final edits.

Then check memory, because this is the single biggest blocker for new UEFN creators. No zone of your island can exceed 100,000 memory units. An island can feel completely fine while you're editing and still fail the moment one area runs too expensive. Don't judge it on overall vibe — one overloaded zone is enough to stop the whole publish.

Next, playtest it like a player, not like the person who built it. Can someone tell what to do? Does a round start and end properly? Do spawns and teams behave? Does the loop still hold after your last change? You know your map too well to see its blind spots — which is exactly why this step matters.

You also have to think across platforms. Developer Rule 1.14 requires the island to be playable on PC, console, and mobile. If a mechanic only feels right with mouse and keyboard, that's a problem to solve now, not after a rejection.

Finally, check your audio early — it's a notorious trap. Epic's scanner can flag audio files even when they're genuinely royalty-free, and the error it throws is vague (often just "Release failed content review"). If you use custom audio, the fastest way to isolate a bad file is brute force: strip all audio, confirm the publish path clears, then add tracks back in halves until the culprit shows up. It's ugly, but it beats guessing one file at a time.

Step 2 — Cook your project and upload a private version

UEFN doesn't publish your island — it cooks the project, calculates its memory, and uploads a private version that shows up in the Creator Portal, where the real publishing continues. This is the single most misunderstood part of the process.

If a guide tells you to publish from a tab inside UEFN and stops there, it's describing half the job. UEFN is the prep-and-upload stage. The Creator Portal is the release stage.

The UEFN side is short. Open your project, click Launch Session, and play-test the island in the running session. Then switch back to the editor and click End Game — this triggers the memory calculation automatically and produces a cooked version of your project. When the memory popup appears, make sure Show in Creator Portal is checked so the data carries over. That cooked version is then uploaded as a private build.

After the upload, your island still is not public. A private version means the project has entered the publishing pipeline — not that anyone can find it. Players can't discover it, and you still owe the Creator Portal a full release package: metadata, media, IARC, attributions, and a visibility choice.

This is the mental shift that trips people up. UEFN's job ends at "the project runs and uploaded." From here on, the question changes from does my island work? to can Epic and players tell exactly what it is?

Step 3 — Fill in your island metadata

Your island metadata tells Epic and players what your island is, how it plays, and what to expect — and getting it wrong can trip moderation before anyone even loads the map. In the Creator Portal you fill in four core fields: title, description, tags, and category.

Keep the title short and concrete, and fold in the game mode or core promise where you can. "Practice Box Fight 1v1" tells a player something; "Epic Fun Map" tells them nothing and earns no trust.

The description should explain what players actually do — the loop, the rules, team sizes if they matter, the kind of experience on offer. The goal is to kill the gap between what the player expects and what they get. If it's a 4v4 objective arena, say so plainly.

Tags and category should match the real island, not chase whatever looks popular. Misleading tags hurt you twice: they annoy players who came for something else, and they're a moderation risk.

Epic's Developer Rules also draw hard lines around metadata. Don't include unauthorized third-party IP, misleading claims, external calls to action, prices, dates, or your Creator Code — Developer Rule 4.2.2 specifically bans Creator Codes in metadata. The rules also restrict copying another creator's island presentation or duplicating your own island to game visibility.

For a beginner, the safe rule fits in one line: describe what the island is, not what you wish players would believe. Clear metadata won't save a weak island, but bad metadata can sink a good one. A deeper guide on island metadata is coming as part of this cluster — for now, accurate and rule-compliant is enough.

Step 4 — Add your thumbnail and promotional media

Your thumbnail and promotional media are part of the release package, not optional decoration — and the thumbnail is mandatory. For UEFN Creator Portal publishing, it needs to be 1920x1080, PNG or JPG, under 5 MB, and it has to represent the real gameplay.

A thumbnail has one job: answer what kind of island is this? in a fraction of a second. If it looks exciting but doesn't communicate the experience, players either skip it or click for the wrong reason and leave. And if it promises something the island doesn't deliver, that's not just lost players — it's a moderation and trust problem.

The mistakes that quietly kill click-through are predictable: too much text, a scene that doesn't show the actual loop, exaggerated rewards, a generic action shot with no mode clarity, or a copycat composition that makes your island feel like a clone. We break these down in common thumbnail mistakes.

You'll also set a lobby background image, shown before players enter. Keep it consistent with the real experience — it shouldn't make a different promise than the thumbnail or title.

A trailer is optional. If you add one, keep it honest: a trailer that hides the real first minute or dresses up a simple island as a cinematic creates the exact same expectation gap as a misleading thumbnail.

Every piece of media should say the same thing — this is what you'll actually get. Media makes a real island easier to understand. It can't rescue a weak one.

Step 5 — Complete the IARC questionnaire

The IARC questionnaire is mandatory — without an age rating, your island gets delisted, even if the project runs perfectly. It's a short form in the Creator Portal that asks what your island actually contains: violence, language, mature themes, music. Your answers generate regional age ratings automatically, including systems like PEGI and ESRB.

Answer it honestly, not optimistically. A rating you talked your way down to isn't a win — classification authorities can re-rate your island after launch, and a mismatch becomes its own delisting risk. The danger isn't only an upfront rejection; it's shipping with the wrong rating and getting pulled later.

Quick personal note, because I've been on the wrong side of this. One of my own maps got rejected in moderation because the age rating didn't exactly match what was in the island — my IARC answers and the map's actual content didn't line up. The build itself was finished and worked fine. The questionnaire is what bounced it. So treat this step as seriously as the build: a rating mismatch alone is enough to reject an island that's otherwise ready to ship.

So before you fill it in, actually review your island against the questions. Does it have combat? Intense themes? Strong language? Music that affects the rating? If the honest answer is yes, the questionnaire has to say yes. And if you change the island significantly later, recheck — the rating should still match what's in the map.

If you're not sure whether something counts, treat that as a review point before you submit, not a thing to gloss over.

Step 6 — Provide attributions for third-party content

If your island uses third-party content — purchased assets, Fab assets, licensed audio — you're required to provide attributions in the Creator Portal. It's easy to forget because the island works perfectly in UEFN without it, but publishing checks whether your content is properly documented, not just whether it runs.

Go through anything in your project that didn't come from you or from default Fortnite and UEFN content: bought 3D assets, Fab assets, music, sound effects, other licensed material. Where attribution is required, add it before you submit.

Don't assume "I paid for it" means "I never have to credit it." Ownership, licensing, and attribution are three different things — if the source requires a credit, include it.

A clean habit here pays off later: keep a running list of every third-party asset, its source, and whether it needs attribution. Once a project grows or gets collaborators, reconstructing that from memory is miserable. Track it from the first publish and every future update gets easier.

Step 7 — Choose your island's visibility

Your island's visibility setting controls who can reach the published version, and the Creator Portal gives you three options: Public, Unlisted, and Private. For a first release, Unlisted is usually the smarter choice — here's what each one actually means.

Public makes the island fully live: anyone can play it, and it's eligible to appear in Discover. It's what most creators picture when they think "published," but it isn't always the best first move.

Unlisted means the island is playable by anyone with the code, but it won't surface in Discover. That's exactly what you want for a controlled first test — real players, real feedback, no broad exposure yet.

Private restricts the island to you and your collaborators only.

For a beginner, the cleanest sequence is: publish the first clean version as Unlisted, share the code with a small group, and watch them play the first minute, the onboarding, the loop, and the obvious bugs. Fix what surfaces. Then flip it to Public once the island holds up for players who didn't build it.

Pro tip: An Unlisted launch is the best free QA you'll get. You already know how your island works — new players don't, and they'll find problems your solo testing never will.

This matters most when nobody outside your own head has tested the map. Visibility isn't just a launch switch — it's a risk control.

Step 8 — Submit for moderation

Once your private version, metadata, media, IARC, attributions, and visibility are all set, the last action in the Creator Portal is Submit for Review. That's the point your island enters Epic's moderation queue.

Epic processes a high volume of submissions — roughly 4,000 a day — and targets a turnaround of around 3 hours, though it can run longer during busy periods. The review combines automated scanning with a human pass. Two outcomes come back: approved or rejected. An approved island gets a public code in the 1234-5678-9012 format and goes live according to the visibility you chose.

A rejection isn't a mystery box, and it isn't the end of the road — but fixing one is its own workflow, and most first-timers fail for a small set of predictable reasons. That's the next section. The key mindset: moderation is the final gate, not the first step. Submit a clean package and it's usually quick. Submit early "just to see," and moderation turns into expensive guesswork.

Common reasons a first UEFN publish fails

Most first UEFN publishes fail for a short, predictable list of reasons: the project isn't technically ready, the metadata or media breaks a rule, the IARC answers don't match the content, attributions are missing, or an automated scan flags audio or copyrighted material.

Before you panic over a rejection, check the usual suspects:

A zone exceeds the 100,000 memory unit budget, or Verse still has errors or warnings.
The island doesn't play properly across PC, console, and mobile.
Metadata is misleading, or contains a Creator Code, an external call to action, a price, or a date.
The thumbnail doesn't reflect real gameplay.
The island uses unauthorized third-party IP, copies another creator's island, or is a near-duplicate.
Audio trips the content scanner.
IARC answers don't match what's in the map, or required attributions are missing.

The most painful case is the generic rejection — audio especially can trigger a broad "Release failed content review" message even on files you believe are royalty-free. That doesn't mean you did something wrong; it means you need to isolate the cause methodically instead of changing things at random. Work through the categories one at a time — technical readiness, metadata, media, IARC, attributions, copyright, audio, rule compliance — so you don't rebuild the whole island when the real blocker was a thumbnail.

Rejection is common enough, and deep enough, to deserve its own guide. For the full breakdown of why islands get rejected and how to recover, read why UEFN islands get rejected in moderation.

Pre-publish checklist

Run this checklist before you submit. It catches the majority of beginner publishing mistakes — and it's worth doing every time, not just on your first island.

Account and program

You're 18 or older, with 2FA enabled.
Your Fortnite account has been connected for 30+ days.
You've actively edited in UEFN or Creative on at least 7 days.
You're enrolled in the Fortnite Developer Program, with your Creator Code, tax interview, and Hyperwallet all set.

UEFN project

Verse compiles with no errors or warnings.
No zone exceeds 100,000 memory units.
The core loop, spawns, and round start/end conditions all work in a real playtest.
The island is playable on PC, console, and mobile.
Any custom or risky audio has been checked.

Upload

You launched a session, ended the game, and let the memory calculation run.
A private version uploaded with "Show in Creator Portal" checked.
The version appears in the Creator Portal.

Creator Portal release package

Title, description, tags, and category match the real island.
Metadata contains no Creator Code, external CTA, price, or date.
Thumbnail is 1920x1080, PNG or JPG, under 5 MB, and reflects real gameplay.
Lobby background is set; trailer added only if it's honest and useful.
IARC questionnaire is completed accurately.
Attributions are provided for all required third-party content.
Visibility is chosen on purpose — Unlisted is the safer first launch.

If every box is ticked, you're not submitting on a hope. You're submitting a clean package — which is exactly what makes moderation fast.

Frequently asked questions

Can you publish a UEFN island for free?

Yes. Publishing itself costs nothing — there's no fee to enroll in the Fortnite Developer Program or to submit an island for review. The only real requirements are meeting the eligibility criteria and setting up a payout account if you want to earn.

How long does UEFN moderation take?

Epic targets around 3 hours, combining automated and human review across roughly 4,000 submissions a day. It can take longer during busy periods, such as right after major Fortnite updates.

Do you need the Fortnite Developer Program to publish a UEFN island?

Yes. You can't publish a UEFN island to other players without enrolling in the Fortnite Developer Program first. Enrollment also handles your Creator Code, tax interview, and payout setup.

Can you publish a UEFN island without setting up payments?

You can publish, but you won't be paid. Engagement payouts and any earnings require a completed tax interview and an active Hyperwallet account, so it's worth finishing that setup before launch.

Why does my UEFN island keep failing content review?

The most common cause is audio — Epic's scanner sometimes flags files even when they're royalty-free, and the error message is often generic. Metadata, third-party IP, IARC mismatches, and missing attributions are the other frequent culprits. Our moderation guide covers each one in detail.

Continue the publishing cluster

Getting your island approved is the first gate, not the finish line. A public code means the island passed moderation — it doesn't mean players understand it, click the thumbnail, or stick past the first minute.

Once your island is live, the work shifts to getting and keeping players. If you want to share your island without coming across as spam, start with how to promote your map without spamming. And if your island has a code but barely any players, why your map gets no players walks through diagnosing whether the problem is visibility, the promise, the thumbnail, the first minute, or the loop itself.

This publishing cluster will keep growing — deeper guides on island metadata, the IARC questionnaire, thumbnail compliance, and getting Discover-ready are on the way. For now, the rule is simple: publish cleanly first, then diagnose what happens once real players touch the island.