An Expo EAS build stuck on "Compressing project files" almost always means the archive being prepared for upload is too large, usually because big assets, node_modules, the .git directory, or build artifacts are being included. Before a build runs, the EAS CLI compresses your project files, excluding what is gitignored and what you list in a .easignore file, and then uploads them, so a large project makes this step slow or seemingly stuck. The fix is to reduce what gets included: add a .easignore to exclude large files not needed for the build, confirm node_modules and .git are ignored, and remove unnecessary bulk from the archive.
Short answer
The build hangs because the project archive is too large, so shrink what gets compressed and uploaded. Per Expo's build reference, the EAS CLI archives your project, excluding gitignored files, and uploads it to build. Add a .easignore file to exclude large files that are not needed for the build, and make sure node_modules, the .git directory, and build artifacts are ignored, since EAS installs dependencies itself. Large media assets included in the archive are a common cause, so check your project size and exclude what the build does not require. Then retry the build with the smaller archive.
What "compressing project files" does
Before an EAS build starts on Expo's servers, the CLI packages your project into an archive and uploads it, and "Compressing project files" is that packaging step. It gathers the files in your project, excluding anything matched by your .gitignore and, if present, your .easignore, then compresses them for transfer. So the size and time of this step depend directly on how much of your project is included.
Understanding this tells you why it can appear stuck. If the archive is large, compressing and uploading it takes a long time, which looks like a hang even though the process is working. So a build that sits on this step is usually not broken; it is moving a lot of data. The way to speed it up is to reduce how much data there is, by excluding files the build does not need.
Are your assets too large?
Large assets are the most common reason this step drags. If your project contains big media files, high-resolution images, videos, audio, design source files, or large test fixtures, and they are included in the archive, they all get compressed and uploaded, which can make the step slow. Not every large file in your repository is needed for the build, and those that are not should be excluded.
Check your project size to see what is contributing. Look for large directories and files, and decide which are actually required to build the app versus which are documentation, source assets, or artifacts that do not need to ship to the build servers. If large media is the cause, either exclude it from the archive when it is not needed for the build, or reconsider whether it should live in the project at all. Reducing the asset bulk is often the single most effective fix, because it attacks the largest contributor to the archive size directly.
How to use .easignore
The .easignore file is the tool for excluding files from the EAS build archive without changing what git tracks. It works like a .gitignore: you create a file named .easignore in your project root and list the files and directories you want excluded from the build upload, one pattern per line. When present, EAS uses it to decide what to leave out of the archive, in addition to your .gitignore.
Use it for anything large that the build does not need but that you do not want to remove from your repository, such as documentation, design files, screenshots, local test data, or media that is not part of the built app. Because .easignore is specific to the build, you can exclude these from the upload while keeping them in version control. Adding a well-targeted .easignore is usually what turns a slow compressing step into a fast one.
What to exclude from the build
A few things should generally be excluded from the archive. node_modules is the biggest, and it should not be uploaded because EAS installs your dependencies on its own servers from your lockfile, so including it just adds enormous, unnecessary bulk. Confirm node_modules is in your .gitignore, which it normally is. The .git directory and build outputs like compiled artifacts and native build folders are also unnecessary for the upload.
Beyond those, exclude large files that are not part of building the app: documentation, design sources, sample media, and test fixtures. The goal is to send only what EAS needs to build your app, not your entire working directory. Keeping the archive to the essential source and configuration, with everything large and non-essential excluded through .gitignore or .easignore, is what keeps the compressing and upload step fast.
Other causes
Not every slow compressing step is purely about size. A slow or unstable network connection lengthens the upload, so if your project is already lean and the step is still slow, your connection may be the limit, and retrying on a faster or more stable network can help. Very large numbers of small files can also add overhead to compression, separate from total size, since each file carries a little bookkeeping cost to package.
These are worth checking after you have trimmed the archive, since size is the more common cause. If you have added a .easignore, confirmed node_modules and .git are excluded, and the project is genuinely small but the step is still slow, then the network or a transient issue is the more likely explanation, and a retry is the reasonable next step.
Causes and fixes
Matching the cause to a fix keeps you from guessing. The table below pairs the common causes with their fixes.
| Cause | Why it is slow or stuck | Fix |
|---|---|---|
| Large media assets | Big files included in the archive | Exclude them with a .easignore |
| node_modules included | A huge directory being uploaded | Ensure it is gitignored; EAS reinstalls |
| .git or build artifacts | Extra unnecessary bulk | Exclude the .git directory and build outputs |
| Nothing excluded | The whole project is compressed | Add a .easignore for non-essential files |
| Slow network | Upload is bandwidth-limited | Retry on a faster, stable connection |
Read the table against your project. Most cases are simply too much being included, which a .easignore and confirming node_modules and .git are ignored will fix, and only a genuinely lean project pointing to the network.
Fix checklist
A short sequence resolves a stuck compressing step. The checklist below covers it.
| Check | Action | Done? |
|---|---|---|
| Add a .easignore | Exclude large files the build does not need | [ ] |
| Ignore node_modules | Confirm it is gitignored, not uploaded | [ ] |
| Exclude .git and builds | Keep the .git directory and artifacts out | [ ] |
| Check project size | Find and address large files and directories | [ ] |
| Retry the build | Re-run EAS build with the smaller archive | [ ] |
The step that resolves most cases is adding a .easignore and confirming node_modules and .git are excluded, since those remove the largest sources of bulk. Trim the archive to what the build needs, then retry.
What to take away
- The build hangs on compressing because the project archive is too large; the CLI compresses and uploads your files before building.
- Large media assets are a common cause, so check your project size and exclude what the build does not need.
- Use a .easignore file to exclude large, non-essential files from the upload without removing them from version control.
- Confirm node_modules, the .git directory, and build artifacts are excluded, since EAS installs dependencies itself.
- Build tooling is separate from app security; after the build succeeds, scan it with PTKD.com before you submit.
