Data sources & methodology

Data sources

Prices are collected automatically from each cloud’s official pricing API. A few values the APIs don’t provide (Azure and GCP instance specs, CloudFront flat-rate plans, Cloud SQL / Memorystore / Cloud Run commitment discount rates, Cloud CDN cache fill rates, etc.) come from the official docs and are recorded in code with the date they were checked.

• AWS — Price List Bulk API (per-region offer files)
• Azure — Retail Prices API
• GCP — Cloud Billing Catalog API
• OCI — price list API (every product; one price for all regions)
• NCP (NAVER Cloud) — the pricing API behind the official cost calculator (KRW, per region)
• Samsung SCP — the price data files behind the official pricing page (KRW)
• NHN Cloud — the per-service price tables loaded by the official pricing page (KRW, per region)
• KT Cloud — the per-product price documents loaded by the official product pages (KRW)
• Exchange rate (USD→KRW) — for display only, refreshed daily (currently $1 = ₩1,334.77)

Collection and validation

Prices are collected automatically once a day. If a run looks abnormal compared to the previous day (many prices swinging ±30%, a sharp drop in item count), we treat it as a collector error and hold the update — a safeguard against showing corrupted data. The “prices collected” date on screen is the last healthy collection.

How estimates are computed

• Monthly cost = hourly price × 730 hours (the convention shared by all three official calculators)
• VM auto-matching: we pick the cheapest instance that satisfies both the requested vCPU and RAM (ties go to fewer vCPUs). The selected instance is always shown in the estimate — we never hide what the comparison is based on. You can also switch to any other instance that meets the specs, and your choice is saved in the share link.
• Burstable instances (AWS t-series, Azure B-series, GCP E2 shared-core) can be included or excluded as an option.
• Storage = capacity × GB-month rate; traffic = cumulative tiered calculation with free allowances applied.

Comparison basis (unified for fairness)

• Linux on-demand list prices (by default — commitment prices below), shared tenancy, current-generation instances only.
• x86 and ARM (AWS Graviton, Azure Dpsv6·Epsv6, GCP T2A·C4A) are compared together by default. ARM is usually cheaper but needs app compatibility, so it is marked with a badge, and the architecture toggle lets you limit results to x86 or ARM.
• Block storage compares the three general-purpose SSDs: AWS gp3 · GCP Balanced PD · Azure Premium SSD v2 (baseline performance included in the price).
• Kubernetes compares SLA-backed standard-tiercontrol planes: EKS standard · AKS Standard · GKE Regional. Worker nodes are matched the same way as regular VMs, except that burstable instances are always excluded regardless of the burstable option (CPU credits don't suit nodes under sustained load). The AKS Free tier (no SLA, free control plane) and GKE's monthly per-billing-account credit (one cluster) are not applied.
• Load balancers compare L7 (HTTP) offerings: AWS ALB · Azure Application Gateway Standard v2 · GCP regional external Application LB. Cost = hourly fixed fee + per-GB processed (AWS LCU and Azure CU are officially defined as 1 GB per hour). Services with very high connection or rule counts may be underestimated.
• NAT gateways are hourly + per-GB processed. GCP Cloud NAT bills hourly per VM, so we count the VMs and K8s nodes in your scenario (capped at 32 per gateway). NAT processing is charged in addition to outbound traffic.
• Managed databases compare MySQL and PostgreSQL on AWS RDS · Azure Database (Flexible Server) · GCP Cloud SQL (Enterprise), picking the cheapest size that meets the requested vCPU and RAM. GCP uses custom sizes fitted to the spec (minimum 3.75 GB memory). High availability includes the standby. Aurora, Enterprise Plus, backup storage and extra IOPS are not included.
• Caches compare Redis-compatible managed caches, picking the cheapest option with at least the requested memory: AWS ElastiCache with the Valkeyengine (Redis-compatible and about 20% cheaper than the Redis OSS engine — AWS's default), Azure Azure Managed Redis (the older Azure Cache for Redis is retiring in 2028), and GCP Memorystore for Redis (priced per GB with capacity-tier rates).
• Cache high availability means one extra replica node on AWS and the Standard tier on GCP. For Azure Managed Redis the pricing API only lists the single-node price, so we estimate HA at 2×based on the pricing page's one-node / two-node (HA) split.
• Serverless containers compare AWS ECS Fargate · Azure Container Apps (Consumption) · GCP Cloud Run (CPU always allocated) running 24/7. Each platform allows different vCPU/memory combinations, so we round up to the cheapest allowed combination that meets the spec (Container Apps: memory = vCPU × 2, up to 4 vCPU; Cloud Run: whole vCPUs). Container Apps and Cloud Run include HTTPS ingress, while Fargate needs a separate load balancer (ALB). Idle-time discounts, request charges (Container Apps $0.4 per million) and monthly free grants are not included. Only Fargate offers ARM.
• CDNs compare AWS CloudFront · Azure Front Door Standard · GCP Cloud CDN, assuming your users are in the same area as the region (Seoul → Korea, Tokyo → Japan, Singapore → Asia Pacific, US regions → North America, European regions → Europe). We add tiered per-GB and per-request rates, Front Door's base fee ($35/month), and GCP cache fill assuming a 90% cache hit ratio. CloudFront uses whichever is cheaper: pay-as-you-go or the cheapest flat-rate plan (Free, Pro, Business, Premium) whose allowance covers your usage. CDN traffic is separate from the outbound traffic card, and transfer from AWS or Azure origins to the CDN is free. The L7 load balancer that Cloud CDN needs is added with the load balancer card.
• Log ingestion compares the standard (searchable) tiers: AWS CloudWatch Logs Standard · Azure Log Analytics Analytics Logs · GCP Cloud Logging. Cost = per-GB ingestion + storage for what accumulates over the retention period; Azure includes 31 days and GCP 30 days, while AWS bills compressed size (15% of raw, its published assumption) from day one. On Azure we use a commitment tier when it is cheaper. Query charges, lower-cost tiers (CloudWatch Infrequent Access, Azure Basic/Auxiliary Logs) and vended logs (VPC flow logs, etc.) are not included.
• Commitment discounts (Pricing: 1-year or 3-year commitment) use instance-specific commitments with no upfront paymenton all three: AWS EC2 Instance Savings Plans (same rates as Standard RIs) and RDS/ElastiCache reserved instances, Azure reservations (monthly and upfront totals are equal), and GCP resource-based committed use discounts (CUDs, billed monthly). More flexible plans (AWS Compute Savings Plans, Azure savings plan) give smaller discounts and are not used, except for serverless containers, which have no instance-specific commitments — there we use each provider's only option (Fargate Compute Savings Plans, Container Apps savings plan, Cloud Run flexible CUDs at 28% / 46%). The cheapest instance is re-matched at commitment prices; SKUs without a commitment offer are priced on-demand and marked "no commitment price".
• Commitments apply only to VM, K8s node, DB, cache and container compute; storage, traffic, CDN, logs, load balancers, NAT and K8s control planes stay on-demand. Where no no-upfront option exists (some 3-year RDS terms), the partial upfront payment is spread over the term's hours. GCP Cloud SQL (25% for 1 year, 52% for 3 years) and Memorystore (20% / 40%, instances of 5 GB or more) use spend-based commitments with no commitment prices in the pricing API, so we apply the discount rates from the official docs. Azure DB high-availability commitment prices assume the standby's vCores are reserved too (2×).
• Free usage: per-account always-free allowances (CloudFront pay-as-you-go 1 TB/month, Container Apps and Cloud Run monthly grants, the GKE monthly credit, the AKS Free tier, etc.) are not applied — a real account may already be using them for other services, so subtracting them for one setup would understate the cost. Free tiers built into the rate tables (traffic) and standalone plans you pick per deployment (the CloudFront Free plan) are included.
• GCP N1, N2, N2D and C2 automatically get a sustained use discount(up to 20–30%) when run for the whole month, but on-demand estimates don't include it; the result notes it when such an instance is selected. Newer series such as E2 (the usual default match) are not eligible.
• Public IP address hourly fees (about $0.005/hour on all three) are not included.
• Object storage uses the standard tier, first pricing band (up to 50TB).
• Outbound traffic is unified on internet routingacross all three: GCP Standard network tier, Azure Routing Preference: Internet, AWS default. (GCP’s Premium tier prices depend on the destination, so a single comparison is not possible.)

OCI comparison basis

OCI is shown separately below the three main clouds. Components OCI doesn’t offer are marked not offered on their line, the total sums the remaining items, and the platform is then left out of the cheapest comparison— so missing items can’t make it look cheaper.

• VMs use OCI’s Flex shapes(E4, E5, Standard3, and A1 for Arm), whose size you choose freely, expanded into representative sizes (vCPU × 1/2/4/8/16 GB per vCPU). OCI bills in OCPUs: 1 OCPU = 2 vCPUs on x86 and 1 vCPU on A1. The newer E6, A2 and A4 are left out because their regional availability can’t be confirmed from public sources. OCI prices are the same in every region; only traffic rates differ.
• Burstable shapes are not included: OCI offers a burstable option priced by a baseline utilization (12.5% or 50%), but it works differently from the CPU-credit model of AWS, Azure and GCP, so it doesn’t fit the current comparison. The “include burstable” option has no effect on OCI, and a server that only uses CPU occasionally may cost less on OCI than shown.
• No commitments: OCI has no per-resource commitment products (only account-level annual credits), so it stays at on-demand prices under 1- and 3-year terms and is marked “no commitment price”.
• Block storage uses Balanced performance (10 VPUs per GB); object storage uses Standard. The first 10 TB of internet traffic per month is free, then $0.025/GB in Asia and $0.0085/GB in North America/Europe.
• Kubernetes uses OKE Enhanced clusters ($0.10/hour), which carry an SLA. Free Basic clusters have no SLA and are not used.
• Load balancers use the Flexible Load Balancer (hourly base + bandwidth per Mbps). The minimum 10 Mbps is included in the hourly price, and processed GB are converted to an average monthly bandwidth. OCI actually bills the maximum bandwidth you configure, so spiky traffic will cost more than shown.
• NAT gateways are counted as $0. The basis: OCI’s official price list, which contains every billable product, has no NAT item (the docs don’t mention a price).
• Managed databases: MySQL uses MySQL HeatWave ECPU shapes (an ECPU is treated as a vCPU, 8 GB per ECPU); high availability runs three instances, tripling compute and storage. PostgreSQL is E5 Flex compute plus a per-OCPU PostgreSQL fee, and storage is Optimized Storage plus the performance charge of the lowest tier (75,000 IOPS = 30 block volume performance units), the same way OCI’s official cost estimator calculates it; high availability uses two nodes, doubling compute, while storage is shared and stays the same.
• Caches use OCI Cache (Valkey/Redis-compatible), priced per GB of node memory; nodes over 10 GB get a lower rate for the whole node. High availability adds one replica (2×).
• Serverless containers use Container Instances (the same price as the matching Compute shape, rounded up to whole OCPUs). They lack autoscaling and HTTPS ingress, so they do less than the other three products, but they are OCI’s only serverless container service.
• OCI has no CDN of its own, so CDN is not offered. Logs use OCI Logging (ingestion free, storage per GB-month); retention tops out at 180 days, so 365 and 730 days are not offered.

NCP (NAVER Cloud) comparison basis

• Prices come from the pricing API behind NCP’s official cost calculator (an undocumented path; if it stops working we will move to the official List Price API). KRW prices are converted to USD at the exchange rate of the collection day, and the same rate converts them back, so KRW figures match NCP’s own prices.
• NCP is offered in Seoul, Tokyo and Singapore. The US and Europe regions have no published VPC server prices, so they show “not offered in this region”.
• VMs are 3rd-generation general servers (Standard, High CPU, High Memory, CPU types; Intel and AMD). Because we assume a full month, we use the monthly rate, about 2% cheaper than the hourly rate × 730. 2nd-generation servers (which bundle a 50 GB disk) and Micro servers (one per account) are left out. NCP has no Arm or burstable servers.
• Block storage is SSD (KRW 0.16 per GB-hour); object storage is Object Storage (KRW 28 per GB-month in Seoul). The first 20 GB of internet traffic per month is free, then tiered rates apply.
• Kubernetes uses the NKS cluster fee (KRW 100/hour); load balancers use the Application Load Balancer Small (KRW 26/hour + KRW 9 per GB processed, first 5 rules free); NAT is KRW 56/hour + KRW 60 per GB processed.
• Managed databases use Cloud DB for MySQL / PostgreSQL server prices; high availability runs two servers (2×). Data storage is billed at the Block Storage SSD rate, and for high availability we assume each server stores its own copy (2×). Tokyo and Singapore only have 2nd-generation DB and cache servers, so those prices are used there.
• Caches use Cloud DB for Redis nodes (1.5–204.8 GB); high availability adds one replica (2×).
• CDN uses Global CDN (tiered per-GB rates + KRW 10 per 10,000 requests). The older CDN+ is marked deprecated by NCP and is not used.
• Logs use the cheaper of Cloud Log Analytics Standard (free ingestion, KRW 800 per GB-month stored) and Premium (KRW 500 per GB ingested, free storage). Each plan caps daily ingestion (20 GB / 100 GB) and stored volume (100 GB / 1 TB); if both are exceeded, logs are marked not offered.
• NCP has no serverless container service (Cloud Functions is functions-as-a-service), so containers are not offered. No commitment products are published, so 1- and 3-year terms stay at on-demand prices.

Samsung SCP (Samsung Cloud Platform) comparison basis

• Prices come from the price data files behind the official pricing page. KRW prices are converted to USD at the collection-day exchange rate — SCP also publishes USD prices, but they use a fixed rate (about KRW 1,150), which would overstate costs when viewed in KRW.
• SCP is offered in Seoul (KR-WEST). The price data only covers Korean regions, so other regions show “not offered in this region”.
• VMs are 3rd-generation general and large Virtual Servers (Intel Granite Rapids) with open-source OS pricing. SCP has no Arm or burstable servers.
• Commitmentsuse Planned Compute (1- or 3-year instance-type commitments, monthly price) — the same kind as the big three’s reserved instances. Cost Savings (an hourly spend commitment) is the flexible kind and is not used. They apply to VMs, databases and caches.
• Block storage is SSD (KRW 120 per GB-month); object storage is Object Storage (KRW 28 per GB-month). The first 20 GB of internet traffic per month is free, then tiered rates apply. Volume discounts above 50,000 GB are not included.
• Kubernetes Engine is billed per cluster-hour, load balancers per LB-hour plus inbound GB, and the NAT Gateway per hour only (no per-GB charge).
• Managed databases use 3rd-generation MySQL / PostgreSQL (DBaaS) server prices. High availability is Active-Standby with two servers, each with its own storage, so compute and storage double. The DB data storage price is not in the DB price table, so we assume the Block Storage SSD rate.
• Caches use CacheStore (Redis-compatible) server prices, treating server memory as cache memory (usable memory is a little lower). High availability adds one replica (2×).
• CDN uses Global CDN tiered transfer rates (no request fee).
• Logs use ServiceWatch logs (per GB). No storage price is published, so only the ingestion fee is counted.
• SCP has no serverless container service (Cloud Functions is functions-as-a-service), so containers are not offered.

NHN Cloud comparison basis

• Prices come from the per-service price tables loaded by the official pricing page; KRW is converted to USD at the collection-day rate (KRW figures match NHN’s own).
• NHN Cloud is offered in Seoul (Pangyo, KR1) and Tokyo (JP1). Tokyo has empty price tables for NKS, NAT Gateway, EasyCache, NCS and RDS for PostgreSQL, so those components are shown as “not offered” there.
• VMs are general Instance types (t2, m2, c2, r2, x1; Linux). Tokyo’s u2 (Basic) bundles dedicated local storage into the server price, so it is left out. There is no Arm, and no public source says t2 is burstable, so it is not treated as burstable.
• Block storage is SSD (KRW 1.6 per 10 GB-hour in Seoul); object storage is Standard (KRW 0.4 per 10 GB-hour). The first 1 GB of internet traffic per month is free, then KRW 100 per GB.
• Kubernetes uses the NKS cluster fee (KRW 100/hour); load balancers use the general Load Balancer (KRW 20/hour, no processing fee); the NAT Gateway is KRW 50/hour (no processing fee).
• Managed databases use RDS for MySQL / PostgreSQL instance prices; high availability adds an identical instance (2×). Data storage uses the SSD rate, doubled for high availability since each instance stores its own copy. Root and backup volumes are not included.
• Caches use EasyCache (Redis-compatible) instance prices; high availability adds a node (2×). The HDD data storage that scales with memory is left out because the ratio isn’t published.
• Serverless containers use NCS (vCPU and memory billed per second); allowed increments aren’t published, so the requested spec is used as-is (up to 16 vCPU and 225 GB per container).
• CDN uses one tiered transfer price for all viewers (no request fee).
• Logs use Log Search from Log & Crash Search: ingestion is free and the plan follows retention (Basic 30 days at KRW 800 per GB-month, Premium 60–120 days at KRW 1,600). 180 days or more is not offered. API calls above 1 million are not included.
• No commitment products are published (contact sales only), so 1- and 3-year terms stay at on-demand prices.

KT Cloud comparison basis

• Prices come from the per-product price documents (tables) loaded by the official product pages; KRW is converted to USD at the collection-day rate. The documents are hand-written tables, so a format change stops collection and keeps the previous data.
• KT Cloud is offered in Seoul only. Managed KS worker nodes and DBaaS run on the D1 platform (DX-M1 zone), so VMs use D1 prices too. VMs are standard and High Memory servers, priced at the monthly rate because we assume a full month. There are no Arm or burstable servers.
• Commitments apply the online VM commitment discount (15% for 1 year, 25% for 3 years) to VMs and K8s nodes. Databases are not eligible and stay at on-demand prices.
• Block storage is the server SSD DISK (KRW 1,400 per 10 GB-month); object storage is Standard (KRW 30 per GB-month).
• Internet traffic comes with a free allowance per server(512 GB under 16 GB of memory, 1 TB at 16 GB or more, pooled per account). We add up the allowance for the scenario’s VMs and K8s nodes (by requested memory) and bill the rest at KRW 90/80/70 per GB tiers. An example on the same page states a different allowance; we follow the price table.
• Kubernetes uses the Managed KS cluster fee (KRW 70,000/month); load balancers are KRW 42/hour + KRW 20 per GB processed.
• Managed databases use DBaaS for MySQL / PostgreSQL (D platform). Each data volume (SSD) comes with a billed backup volume twice its size, so storage is three times the data size. High availability is two DB VMs + one monitor VM for PostgreSQL (documented) and a cluster of three DB VMs + two router VMs for MySQL — the minimum MySQL cluster size isn’t published, so three is an assumption.
• CDN uses CDN Standard (tiered transfer + KRW 10 per 10,000 requests).
• NAT and log ingestion have no published prices, the cache (DBaaS for Cache) is in a free open beta without regular pricing, and there is no serverless container service — all are shown as not offered.

Limitations — what this estimate does not tell you

• Estimates default to list prices. Under “Pricing” you can pick 1- or 3-year commitments (as described above); combinations of commitments, Spot/preemptible instances, negotiated discounts (EDP, etc.), credits and per-account free allowances are not reflected — your actual bill may be lower.
• Extra storage IOPS/throughput, object storage API requests, snapshots and backups, cross-AZ and cross-region data transfer, monitoring metrics and queries, and support plan fees are not included.
• Every resource is assumed to run all month (730 hours). Setups whose usage varies — autoscaling, shutting down at night — will come out higher than reality.
• Taxes such as VAT are not included (they depend on your country — 10% in Korea).
• Azure and GCP pricing APIs carry no specs, so only main series are cataloged (Azure: B·Bsv2/Dsv5·Dsv6/Esv5·Esv6/Fsv2/Dpsv6·Epsv6; GCP: E2/N1/N2/N2D/N4/N4D/C2/C2D/C3/C3D/C4/C4D/T2D/T2A/C4A). Some series such as Azure AMD variants (Dasv6, etc.) are not included, so the true cheapest option may differ.
• These estimates are meant for structural comparison and ballparking, not as a basis for contracts or billing.