How Much RAM Does a Modded Minecraft Server Need? (2026)
Modded Minecraft needs 4–12 GB RAM — not vanilla's 1 GB. Exact specs for FTB, ATM9, Create, RLCraft, and how to configure Aikar's Java flags to fix lag.
Every week, someone in an Indian Minecraft Discord posts the same complaint: "My modded server keeps crashing" or "TPS is 4, what do I do?" The reply is almost always "add more RAM" — and while that advice is not wrong, it is radically incomplete.
Modded Minecraft server performance has almost nothing to do with how much RAM you throw at it if everything else is wrong. You can give a badly configured server 32 GB of RAM and it will still lag. Meanwhile, a correctly configured server with 6 GB of RAM can run a 200-mod pack with 8 players silently.
This guide explains the actual mechanics: what RAM does in a Minecraft server, why modded packs need so much more of it, how CPU and storage bottlenecks are more commonly the real cause of lag, what Aikar's flags are and why you must use them, and exactly what hardware to buy (or rent) for every popular modpack running in India right now.
The Direct Answer
A modded Minecraft server needs a minimum of 4 GB RAM for small packs under 50 mods, 6–8 GB for medium packs of 100–200 mods, and 10–12 GB for large packs like All the Mods 9 or FTB Infinity. Beyond RAM, a fast single-core CPU (3.5 GHz+ clock speed) and NVMe storage are non-negotiable for modded — they matter more than raw core count or extra RAM.
Why Vanilla RAM Numbers Are Useless for Modded
The official Minecraft server recommendation of 1 GB RAM applies to a vanilla server with no mods. A vanilla server runs the Minecraft game loop, handles up to 20 entities per player, and manages chunk loading for a handful of loaded chunks. It is a lean process.
A modded server is a fundamentally different program. Every mod you install adds its own Java classes to the JVM heap, its own server-side tick handlers, its own entity types, its own chunk generation hooks, and often its own background threads. When you install 300 mods, you are not running Minecraft plus 300 small additions — you are running a new piece of software that happens to share a codebase with Minecraft.
Here is what actually consumes memory in a modded server:
Java class metadata: Each mod loads dozens to hundreds of Java classes into the JVM's metaspace (a non-heap memory region). A 300-mod pack can load 80,000–150,000 unique classes. Metaspace is separate from your -Xmx heap setting and can consume an additional 1–3 GB of JVM memory that most RAM calculators ignore.
Loaded chunk data: Vanilla keeps a relatively small number of chunks loaded around each player. Tech mods (Create, Applied Energistics, Mekanism, Thermal Expansion) introduce chunkloaders — blocks that keep distant chunks loaded indefinitely for their machines to run. A single active Create factory can keep 20–50 chunks loaded permanently. Each loaded chunk holds block state data, tile entity data, entity AI state, and lighting data. A tech-heavy modpack server can have 5–10× more actively loaded chunks than a vanilla server with the same player count.
Entity AI computation: Mods like Alex's Mobs, Mowzie's Mobs, and Mutant Creatures add entities with significantly more complex AI state machines than vanilla mobs. More AI state = more heap memory per entity. A server with 200 custom entities can use 2–3× the memory that vanilla entities would consume.
World generation: Biome and terrain mods (Terralith, Alex's Caves, Biomes O'Plenty, Oh the Biomes You'll Go) do not just change what chunks look like — they replace Minecraft's worldgen pipeline with their own, which runs on every new chunk generation. This is primarily a CPU cost, but it also holds large temporary data structures in memory during generation, causing brief heap spikes that can trigger garbage collection at the worst possible moment.
The Three Bottlenecks: RAM, CPU, and Storage
Performance problems in modded Minecraft almost always trace back to one of three bottlenecks. Identifying which one is killing your server is more important than blindly upgrading any single resource.
Bottleneck 1: RAM (Heap Exhaustion and GC Pressure)
If your server is crashing with java.lang.OutOfMemoryError, you have a RAM problem. But there is a subtler form of RAM bottleneck that most people misidentify as a CPU problem: garbage collection (GC) pauses.
Java's garbage collector periodically scans the heap to reclaim objects that are no longer referenced. During a GC pause, the entire JVM stops — including the Minecraft game loop. This shows up as a TPS spike on the spark profiler: TPS drops to 0 or near-zero for 200–500ms, then recovers. Players experience this as sudden freezes where everyone is teleported back a few blocks.
The fix for GC pauses is not always more RAM — it is better GC configuration. This is exactly what Aikar's flags solve. If you are not using Aikar's flags, you are using Java's default GC settings, which were designed for generic Java applications, not a game server that generates and discards millions of short-lived objects per second.
Symptom checklist for RAM bottleneck: - Server crashes with OutOfMemoryError - TPS regularly drops to 0 for 200–500ms intervals (visible in spark as GC events) - free -h on the server shows swap being used - Memory usage in spark profiler reaches 90%+ of -Xmx allocation
Bottleneck 2: CPU (Single-Thread Starvation)
Minecraft's main game loop — the part that processes player movement, block updates, entity AI, and redstone — runs on a single thread. It does not matter if your server has 16 CPU cores. If the single main thread cannot complete one full tick within 50ms (1/20th of a second), your TPS drops below 20.
Mods that add complex per-tick processing (advanced machine logic, per-tick entity pathfinding for large mob farms, real-time fluid simulation) stack their work onto this single thread. A tech modpack server with 10 active Create factories, 5 Mekanism machine setups, and a mob farm running 500 custom entities can saturate a single CPU core completely — and adding more RAM will do absolutely nothing for the lag.
The fix is a faster single-core CPU, not more cores. This is the most important hardware specification that generic hosting panels hide from you. A 4-core CPU at 4.0 GHz will perform better for a modded Minecraft server than an 8-core CPU at 2.8 GHz. Clock speed per core beats core count for vanilla and lightly modded servers. For heavily modded packs, it is close — Forge has made significant improvements in threading tick processing across 1.18–1.21 — but single-core performance still dominates for the core game loop.
Symptom checklist for CPU bottleneck: - TPS is consistently 14–18 (low but not zero — not GC pauses) - spark profiler shows main thread usage at 80–100% - Server does not crash; it just lags constantly - Adding more RAM makes no difference - Lag spikes coincide with chunk generation or machine updates
What to do: Use the /spark tps and /spark profiler commands to identify which mod's tick handler is consuming the most main-thread time. Often a single badly written mod is responsible for 40% of tick time, and disabling or replacing it resolves the lag entirely.
Bottleneck 3: Storage I/O (The Overlooked Killer)
This is the most underdiagnosed bottleneck in Indian modded Minecraft communities. Most budget hosting uses HDD storage. Modded Minecraft generates enormous amounts of chunk data — a 300-mod pack generates chunks that are 5–15× larger than vanilla chunks because every mod can store tile entity data, custom block states, and biome overlay information per chunk.
When a player runs or flies through unexplored territory, the server must generate and save new chunks as fast as the player moves. On an NVMe SSD, chunk generation I/O completes in microseconds. On a spinning HDD, the same operation takes 5–15ms of disk wait time — and because the game loop waits for chunk saves before the next tick in some circumstances, this directly causes TPS drops.
The test: Run /spark profiler and look at the profiler output. If you see ChunkSerializer or RegionFileCache consuming significant time on the main thread, your storage is the bottleneck, not your RAM or CPU.
The fix: NVMe storage. This is non-negotiable for any modded pack above 100 mods. When comparing hosting plans, always ask whether the storage is NVMe or HDD. The difference in modded Minecraft chunk generation performance between NVMe and HDD is 10–20× in I/O throughput.
Mod Count as a Resource Multiplier
Here is a practical framework for estimating requirements before you buy hosting:
| Mod Count | RAM (server-side) | CPU Minimum | Storage |
|---|---|---|---|
| Vanilla (0 mods) | 1–2 GB | Any | HDD acceptable |
| Lightly modded (1–30 mods) | 2–4 GB | Any, 2.5+ GHz | HDD acceptable |
| Small pack (30–80 mods) | 4–6 GB | 2 cores, 3.0+ GHz | SSD recommended |
| Medium pack (80–200 mods) | 6–8 GB | 4 cores, 3.5+ GHz | NVMe required |
| Large pack (200–350 mods) | 8–12 GB | 4–6 cores, 3.8+ GHz | NVMe required |
| Mega pack (350+ mods) | 12–16 GB | 6+ cores, 4.0+ GHz | NVMe required |
These are server-side values. Client-side RAM (what players need on their own PC) is a separate calculation — clients typically need 1.5–2× server RAM for the same pack because they also load textures, sounds, and rendering pipelines.
Popular Modpacks: Exact Requirements for Indian Servers
These specifications are based on the pack versions current in 2026 and assume 4–8 concurrent players (the most common Indian friend-group server size). Add 1–2 GB for each additional 5 players beyond 8.
All the Mods 9 (ATM9) — Forge, ~400 mods
ATM9 is the most resource-intensive popular pack. It includes nearly every major tech and magic mod, full biome overhaul with Alex's Caves and Terralith, and dense machine automation content. Do not underestimate it.
- Minimum: 10 GB RAM, 4 cores at 3.8+ GHz, NVMe storage
- Recommended: 12 GB RAM, 6 cores at 4.0+ GHz, NVMe
- Java flags: Aikar's flags (see below),
-Xms10G -Xmx10G(matching min and max prevents heap resize pauses) - Indian hosting budget: ₹2,000–3,500/month for a properly speced plan
FTB Revelation — Forge, ~200 mods
Revelation is a kitchen-sink pack with a strong tech mod focus. Heavy machine usage from players will stress the single-core CPU.
- Minimum: 6 GB RAM, 4 cores at 3.5+ GHz, NVMe
- Recommended: 8 GB RAM, 4–6 cores at 3.8+ GHz, NVMe
- Notes: Mekanism and Thermal Expansion machines are tick-heavy. Limit concurrent active machines in early game until the server's CPU headroom is established.
Create: Above and Beyond — Forge, ~80 mods
One of the best-designed packs for performance. Create's kinetic simulation is CPU-heavy during machine construction but levels off once designs are finalised. Fewer mods means smaller metaspace overhead.
- Minimum: 4 GB RAM, 2 cores at 3.5+ GHz, NVMe
- Recommended: 6 GB RAM, 4 cores at 3.5+ GHz, SSD or NVMe
- Notes: Create's contraptions (trains, moving platforms) can spike CPU during movement. If players build extensive train networks, monitor main-thread usage with spark.
RLCraft — Forge, ~160 mods
RLCraft is the opposite of a well-optimised pack — it was designed for maximum difficulty, not maximum performance. The Lycanites Mobs system spawns complex-AI custom entities constantly, and the pack has no built-in performance mods.
- Minimum: 6 GB RAM, 4 cores at 3.8+ GHz, NVMe
- Recommended: 8 GB RAM, 4–6 cores at 4.0+ GHz, NVMe
- Critical: Add FerriteCore, Smooth Boot (Reloaded), and Clumps manually to the server. RLCraft without these performance mods will lag significantly even on good hardware.
SkyFactory 4 — Forge, ~200 mods
SkyFactory 4 is a void-world pack, which means chunk generation is almost zero (the world is almost entirely empty). This eliminates one of the biggest bottlenecks. However, the tech mod automation expected by players is extremely dense.
- Minimum: 6 GB RAM, 4 cores at 3.5+ GHz, SSD (NVMe not required due to minimal chunk generation)
- Recommended: 8 GB RAM, 4 cores at 3.8+ GHz, SSD
- Notes: The void world makes storage less critical, but automation density still makes CPU the bottleneck at mid-to-late game.
Valhelsia 6 — Forge, ~250 mods
A balanced pack with strong biome overhaul mods and a mix of tech, magic, and exploration. Moderate resource demands with good internal optimisation.
- Minimum: 6 GB RAM, 4 cores at 3.5+ GHz, NVMe
- Recommended: 8 GB RAM, 4 cores at 3.8+ GHz, NVMe
Enigmatica 9 — NeoForge, ~250 mods
One of the more performance-conscious large packs. Uses NeoForge, which has better parallel processing than older Forge versions.
- Minimum: 6 GB RAM, 4 cores at 3.5+ GHz, NVMe
- Recommended: 8 GB RAM, 4–6 cores at 3.8+ GHz, NVMe
Project Ozone 3 — Forge, ~250 mods
An older but still popular pack in Indian communities. Based on Minecraft 1.12.2, which uses an older Java version (Java 8). Metaspace handling and GC in Java 8 is less efficient than Java 17+.
- Minimum: 6 GB RAM, 4 cores at 3.5+ GHz, SSD
- Recommended: 8 GB RAM, 4 cores at 3.8+ GHz, NVMe
- Java version: Must use Java 8. Do not use Java 17 with 1.12.2 packs.
Aikar's Flags: The Most Important Configuration You Are Probably Not Using
Aikar's flags are a set of JVM garbage collection arguments developed specifically for Minecraft servers. They configure the G1 garbage collector (G1GC) to behave in a way that minimises stop-the-world GC pauses by collecting garbage in smaller, more frequent increments rather than large occasional sweeps.
Here is the complete flag set for a server with 10 GB RAM allocated:
java -Xms10G -Xmx10G -XX:+UseG1GC -XX:+ParallelRefProcEnabled -XX:MaxGCPauseMillis=200 -XX:+UnlockExperimentalVMOptions -XX:+DisableExplicitGC -XX:+AlwaysPreTouch -XX:G1NewSizePercent=30 -XX:G1MaxNewSizePercent=40 -XX:G1HeapRegionSize=8M -XX:G1ReservePercent=20 -XX:G1HeapWastePercent=5 -XX:G1MixedGCCountTarget=4 -XX:InitiatingHeapOccupancyPercent=15 -XX:G1MixedGCLiveThresholdPercent=90 -XX:G1RSetUpdatingPauseTimePercent=5 -XX:SurvivorRatio=32 -XX:+PerfDisableSharedMem -XX:MaxTenuringThreshold=1 -Dusing.aikars.flags=https://mcflags.emc.gs -Daikars.new.flags=true -jar server.jar nogui
Replace 10G with your actual RAM allocation. Always set -Xms and -Xmx to the same value — this prevents the JVM from resizing the heap at runtime, which causes its own pause events.
What each critical flag does:
-XX:+UseG1GC — Switches from the default collector to G1GC, which was designed for large heaps and low-latency applications.
-XX:MaxGCPauseMillis=200 — Instructs G1GC to target GC pauses under 200ms. The collector prioritises hitting this target rather than collecting as much garbage as possible per cycle.
-XX:InitiatingHeapOccupancyPercent=15 — Starts concurrent GC collection when the heap is only 15% occupied, rather than waiting for high occupancy. This keeps garbage collected before it accumulates into a large sweep.
-XX:+AlwaysPreTouch — Allocates all memory pages at JVM startup rather than on-demand. Prevents OS-level page faults during play, which can cause mysterious lag spikes unrelated to any mod.
-XX:+DisableExplicitGC — Prevents mods from triggering manual garbage collection via System.gc(), which can cause large unexpected pauses. Some older mods call this in good faith; this flag makes those calls no-ops.
For servers with more than 12 GB RAM (Java 17+ only), consider switching to ZGC instead of G1GC:
-XX:+UseZGC -XX:+ZGenerational
ZGC is designed for very large heaps and achieves sub-1ms GC pauses by doing almost all collection work concurrently. It is not available on Java 8 and performs best on Java 21+.
Optimization Mods That Reduce Requirements by 20–40%
Before buying more RAM or CPU, install these performance mods. They are free, widely compatible, and often reduce resource requirements more than a hardware upgrade would.
For Forge Packs
FerriteCore — Reduces RAM usage by 20–30% by deduplicating block state objects in memory. This is one of the highest-impact mods available. Compatible with nearly all Forge packs from 1.16 onwards.
Smooth Boot (Reloaded) — Limits the number of threads used during server startup, preventing the JVM from spawning hundreds of threads simultaneously and causing GC pressure during the first 60 seconds. Does not affect runtime performance but prevents crash-on-startup from memory spikes.
Clumps — Merges experience orbs that are close together into single entities. Large mob farms or player deaths can create hundreds of XP orbs, each an independent entity. Clumps reduces this to one entity per cluster, cutting entity AI processing significantly.
ServerCore — Reduces mob spawning density, caps entity counts per chunk, and optimises chunk loading for server-side use. Configurable — can be tuned to be less aggressive if you do not want mob spawning changes.
Chunky (Pre-generation) — Not a runtime performance mod but essential for new servers. Pre-generates a defined radius of chunks before players start playing. This eliminates the chunk generation lag that occurs when players explore, spreading it over a single pre-generation session instead of during play. For a 10,000-block radius, run Chunky overnight before opening the server.
For Fabric Packs
Lithium — Rewrites large portions of Minecraft's game logic (pathfinding, chunk ticking, entity collisions) with optimised algorithms that maintain vanilla behaviour. 15–30% TPS improvement on typical servers at no visible gameplay cost.
Starlight — Replaces Minecraft's lighting engine, which is notoriously inefficient. Starlight eliminates lighting-related lag spikes during chunk loading and reduces RAM usage for lighting data.
Krypton — Optimises the Minecraft network stack, reducing CPU usage for packet serialisation and deserialisation. Matters most for servers with 10+ players.
Spark — Not strictly a performance mod but a profiler that runs as a mod. Use /spark profiler to identify exactly which mod or system is consuming the most CPU time. Without spark, diagnosing lag is guesswork; with spark, it takes 60 seconds.
Scaling for Player Count: How Requirements Change
The specifications above assume 4–8 players. Here is how to scale:
| Players | RAM multiplier | CPU note |
|---|---|---|
| 1–4 | Base spec | Fine at base clock speeds |
| 5–8 | Base spec | Monitor main-thread usage |
| 9–15 | +2 GB RAM | Consider upgrading CPU tier |
| 16–25 | +4 GB RAM | 6+ cores, 4.0+ GHz strongly recommended |
| 26–40 | +6 GB RAM | Consider dedicated server, not VPS |
| 40+ | Custom architecture | Multiple servers + proxy (Velocity/Waterfall) |
The RAM scaling is roughly linear. CPU scaling is less predictable — 10 players doing nothing contributes minimal load; 10 players each running separate automated machine setups will multiply CPU demand significantly.
For Indian friend-group servers (the most common use case — 4–8 people), base specifications are almost always sufficient if the configuration is correct (Aikar's flags, optimisation mods, pre-generated chunks).
What to Buy: Indian Hosting Recommendations by Pack Type
When evaluating hosting plans in India for modded Minecraft, ask three questions before anything else:
"Is the storage NVMe or HDD?" If the answer is HDD, look elsewhere for any pack above 100 mods. The chunk generation performance on HDD is genuinely unacceptable for modded play.
"What is the CPU model and clock speed?" Generic VPS plans often use Intel Xeon or AMD EPYC processors running at 2.4–3.2 GHz. These processors prioritise throughput across many cores over single-core clock speed. For modded Minecraft, you want 3.5 GHz or higher per core. Ask specifically — good providers will tell you.
"Is the RAM shared or dedicated?" On some budget VPS plans, memory is over-provisioned (multiple VMs compete for the same physical RAM). This creates unpredictable GC behaviour and is a common hidden cause of intermittent lag that disappears under profiling because it looks like GC pauses.
| Pack Type | Minimum Plan to Look For | Monthly Budget (INR) |
|---|---|---|
| Small pack <50 mods | 4 GB RAM, 2 vCPU, SSD | ₹600–900 |
| Medium pack 50–150 mods | 6 GB RAM, 4 vCPU, NVMe | ₹900–1,400 |
| Large pack 150–300 mods | 8 GB RAM, 4–6 vCPU, NVMe | ₹1,400–2,200 |
| Mega pack 300+ mods (ATM9) | 12 GB RAM, 6 vCPU, NVMe | ₹2,200–3,500 |
These are 2026 Indian market price ranges for game-hosting-specific plans (not generic VPS). Game-hosting providers typically include a Minecraft panel (Pterodactyl or Multicraft), pre-installed Java versions, and DDoS protection that generic VPS plans do not.
Common Mistakes That Cause Modded Minecraft Lag in India
Allocating too much RAM. Counterintuitively, allocating more RAM than the server needs causes longer GC pause events because G1GC has more heap to scan. For a 150-mod pack, allocating 16 GB when 8 GB is sufficient will not help — it may actually make GC pauses worse. Match RAM allocation to actual usage plus a 20% headroom buffer.
Not pre-generating the world. New servers that open without pre-generating chunks suffer severe lag for the first few hours of play as each player's movement triggers chunk generation. Run Chunky or the /pregen command for 3,000–5,000 blocks in every direction before inviting friends.
Using default Java startup scripts from Forge installers. The script that Forge generates looks like: java -Xmx2048M -Xms2048M -jar forge.jar. This uses default GC settings, which are catastrophically wrong for Minecraft. Always replace with Aikar's flags.
Running Java 8 for 1.16+ packs. Java 17 has significantly better G1GC and ZGC implementations than Java 8. Minecraft 1.17+ requires Java 17 minimum. Do not use Java 8 for any pack above 1.16.
Hosting on a home internet connection. This one is specific to India. Several Indian gaming communities run their server on a home PC with a Jio or Airtel Fiber connection. Home ISP connections have variable upstream bandwidth, do not have DDoS protection, and are often behind CGNAT (which means the IP is shared across many users and will change). A ₹600/month game hosting plan provides a more stable experience than a high-end home PC running off residential internet.
Installing the full client modpack on the server. Client mods — shader packs, minimap mods, inventory management mods, resource pack loaders — have no function on the server. Installing the full client pack on the server wastes RAM and adds unnecessary classpath entries. Server-side modpacks should contain only mods with server-side functionality.
The Indian Cracked Modpack Problem
A significant portion of Indian Minecraft players run cracked (unlicensed) copies of Minecraft, and modpacks for cracked launchers circulate in WhatsApp groups and Telegram channels. These unofficial distributions are often months or years out of date, include mods removed from the official pack for performance reasons, and occasionally contain additional software bundled without disclosure.
Beyond the ethical and legal dimension, these packs cause two concrete problems. First, they are often built against outdated Forge or Fabric versions with known memory leak bugs that were patched in later releases. Second, they frequently include mods that have been removed from the official distribution because they were identified as causing crashes or severe lag. Running a server on an unofficial modpack tarball from a Telegram channel is the single most common cause of "unexplained" crashes in Indian modded servers.
The solution is straightforward: use the official CurseForge App or Modrinth App to download modpacks. Both support legitimate free use and provide pack versions that are tested and have proper dependency resolution. Minecraft Java Edition is available for a one-time purchase of approximately ₹1,500 and is a significantly better experience than any cracked alternative.
FAQ
How much RAM does a modded Minecraft server need for 4 players in India? For 4 players on a medium pack (100–200 mods like FTB Revelation or Valhelsia), 6–8 GB RAM with Aikar's flags is sufficient. All the Mods 9 needs 10 GB even for small groups. Small Create packs under 80 mods can run well on 4 GB.
Why does my modded server have low TPS even with 16 GB RAM? Low TPS with plenty of RAM is almost always a CPU bottleneck — specifically, the Minecraft main thread is overloaded. Run /spark profiler for 60 seconds and identify which mod is consuming the most tick time. Reduce active machines, limit mob farm size, or disable the problematic mod.
What is the difference between Forge and Fabric for server performance? Fabric generally has better server performance due to a more lightweight mod loader and better optimisation mods (Lithium, Starlight). Forge is more feature-rich and has more popular large packs. NeoForge (a Forge fork from 1.20.1 onwards) bridges this gap with improved threading. For performance-first servers, Fabric with Lithium is faster.
Do I need NVMe storage for a modded Minecraft server? Yes, for any pack above 100 mods. NVMe storage is 10–20× faster than HDD for random I/O operations, which is exactly what Minecraft chunk generation and saving requires. On an HDD, players exploring new territory will cause visible server lag. On NVMe, chunk generation is nearly instant.
What Java version should I use for a modded Minecraft server? Minecraft 1.17+ requires Java 17 minimum. Use Java 21 for best G1GC and ZGC performance on 1.20.1+ packs. For legacy 1.12.2 packs (Project Ozone, older FTB packs), use Java 8. Never mix Java versions between client and server — both must match the pack's requirements.
What is Chunky and why should I run it before opening my server? Chunky is a Forge/Fabric mod that pre-generates world chunks before players load them. Running /chunky start and pre-generating a 5,000-block radius before your first play session eliminates the chunk generation lag that occurs during the first few hours of a new server. It is a one-time operation that dramatically improves new-server experience.
Can I run ATM9 on a 8 GB plan? Technically yes, but expect lag. ATM9 recommends 10–12 GB server-side. On 8 GB, you will see frequent GC pauses, occasional OutOfMemoryError crashes once players build up automation, and slow chunk generation. If 8 GB is your budget, consider All the Mods 8 or Valhelsia 6 instead.
Is a dedicated server better than a VPS for modded Minecraft? For packs above 200 mods or player counts above 15, a dedicated server (bare metal) outperforms a VPS because you get guaranteed CPU access, no noisy-neighbour effects from other VMs on the same physical host, and typically faster storage. For small friend-group servers on packs under 200 mods, a properly speced game hosting VPS is sufficient and significantly cheaper.
Conclusion
The answer to "how much RAM does my modded Minecraft server need" is rarely just a number — it is a function of mod count, mod type, player count, Java configuration, and storage speed working together. A 12 GB server with default Java flags and HDD storage will perform worse than a 6 GB server with Aikar's flags, FerriteCore, and NVMe storage.
The priority order for setting up a modded server correctly in India is: first, get NVMe storage (not negotiable for packs above 100 mods); second, apply Aikar's flags (free, takes five minutes, eliminates GC pauses); third, install FerriteCore and Clumps (free, 20–30% RAM reduction); fourth, pre-generate your world with Chunky; and finally, scale RAM to actual usage plus 20% headroom. Follow this order and you will spend less money and have a better-running server than someone who skipped all of it and bought the most expensive plan available.