Spotlight

Case Study Microsoft

How Microsoft scaled global content delivery

Find out how Microsoft used Gcore to strengthen delivery across regions.

case study ProSieben GNTM app TOPSHOT

How ProSieben scaled GNTM's app TOPSHOT

Explore how ProSieben brought real-time AI portraits to GNTM's audience.

case study Higgsfield

How Higgsfield scaled AI video generation

See how Gcore helped Higgsfield scale with GPUs and Managed Kubernetes.

case study Fawkes Games

How Fawkes Games stopped DDoS attacks

See how Gcore protected gaming servers from massive DDoS threats without disrupting gameplay.

We're hiring

Help build the next chapter of the web

We're not just filling seats. We're building a team that will write the next chapter of the internet.

FastEdge

Run application
logic
where
requests happen

Store assets, backups, logs, and app data in S3-compatible storage that gives content a cleaner route to the edge. Keep familiar tools, control access, and remove extra origin work between storage and delivery.

  • No credit card needed
  • Start in 2minutes 
  • Generous FREE tier
An abstract illustration showing a central globe connected to servers, code, and browser windows.
POWERING TEAMS AT
Microsoft
RTL
letz.AI
WARGAMING.NET
SAW
leaseweb

Build, ship, and respond from the edge

Deploy edge logic without provisioning servers, managing regions, or rebuilding your backend for every new request-time decision.

BUILD

01

Start with code or a template

Write request-time logic in JavaScript or Rust, or
use a FastEdge template for routing, access, personalization, and more.

SHIP

02

Deploy it across the edge

Push your FastEdge application through the Portal, API, CLI, or Terraform, then
run it closer to users on Gcore’s edge network.

RESPOND

03

Serve the right response

Run decisions at the edge, use nearby data for fast reads, and send traffic back to origin only when it is needed.

No servers to provision
No regions to manage
Portal, API, CLI, and Terraform deployment
Edge Storage when logic needs data

Built for edge logic. Without the server work.

Move routing, access, personalization, and transformation logic closer to users
while keeping server setup and runtime operations out of your way.

JS / Rust SDK
Build in familiar ways

Build in familiar ways

Create FastEdge apps with documented JavaScript and Rust SDK paths, then deploy them as WebAssembly applications at the edge.

JavaScriptRustWebAssembly
Portal · API · CLI
Deploy without provisioning

Deploy without provisioning

Push apps through the Customer Portal, API, CLI, or Terraform and bring edge logic online without managing servers, regions, or infrastructure.

Customer PortalAPICLITerraform
Wasm sandbox
Run in an isolated sandbox

Run in an isolated sandbox

Keep edge applications isolated inside a WebAssembly sandbox designed for controlled request execution.

App isolationControlled execution
Usage-based
Scale with real traffic

Scale with real traffic

Handle changing demand without pre-provisioning capacity or paying for idle infrastructure your application is not using.

No idle capacityAuto scale
Edge Storage
Connect what logic needs

Connect what logic needs

Use Secrets Manager for sensitive values and Edge Storage for fast reads from rules, flags, entitlements, or policy data.

Secrets ManagerFast reads

Keep data where
decisions happen

Add Edge Storage when your edge logic
 needs fast reads from rules, flags, entitlements, allowlists, blocklists, or policy data.
 Keep the right data close to the request, and
send traffic back to origin only when needed.

  • Built for read-heavy edge data
  • Global write replication, typically within seconds
  • Good fit for flags, rules, entitlements, and allowlists
Gcore FastEdge Keep Data At The Edge Where Functions Computing And Decisions Happen

CDN delivers. FastEdge handles the logic.

Fast delivery is only the start. Access checks, routing, personalization, and response changes still go back
to origin unless they run at the edge. FastEdge puts that logic closer to your users.

Adapt experiences in real time
Personalization
Adapt experiences in real time

Change content, language, currency, experiments, or feature flags based on request context and nearby data.

Feature flagsA/B testsLocalization
Check access before origin
Access Control
Check access before origin

Validate tokens, signed parameters, IPs, keys, and entitlement data before protected content is served.

JWT validationIP listsEntitlements
Send requests the right way
Traffic Routing
Send requests the right way

Apply geo rules, release windows, failover logic, or smart-origin selection closer to the user.

Geo routingCanary releasesFailover
Change responses at the edge
Response Logic
Change responses at the edge

Modify headers, rewrite URLs, transform content, or shape frontend responses before they reach the user.

Header & URL rewritesHTML transformContent shaping
Run lightweight apps closer
Edge Applications
Run lightweight apps closer

Serve frontend responses, small APIs, generated files, or dynamic content directly from the edge.

Edge APIsFrontend responsesGenerated files
Reduce backend work
Origin Offload
Reduce backend work

Move repeat checks, lightweight API logic, and high-frequency policy reads to the edge so origin handles only what it needs to.

Lightweight APIsRepeat checksPolicy reads

More of your edge stack. Less patchwork.

Bring delivery, compute, data, and security closer together on Gcore's edge platform.
Keep your request path growing without turning every new layer into another vendor project.

DELIVERY LAYER
210

Edge Points of Presence

Delivering content closer to users around the world.

DELIVERY LAYER
210

Edge Points of Presence

Delivering content closer to users around the world.

COMPUTE LAYER
<1

EDGE COMPUTE COLD START

Run WebAssembly logic at the edge without noticeable startup delay.

DATA LAYER
sec

GLOBAL DATA REPLICATION

Distribute flags, rules, and entitlements across the edge.

Connect logic to CDN delivery
Route by location, health, or context
Read edge data before origin

See the logic in action

Five FastEdge functions running on real Gcore edge servers. Pick a demo to see what it does and how it's written.

Streaming transform

Rewrite HTML at the edge before it reaches the browser

Modify any HTML element — headings, links, attributes, or inner content — directly in the response stream, without touching your origin server.

Cold start<1ms
RuntimeWebAssembly
Filerewriter.ts
rewriter.ts<1ms
// FastEdge — HTML Rewriter
import { HTMLRewriter } from "fastedge:html";

export default async function handler(req: Request) {
  const res = await fetch(req);
  return new HTMLRewriter()
    .on("h1", {
      element(el) {
        el.setInnerContent("Hello from the edge");
      }
    })
    .transform(res);
}
Edge-native storage

Accept uploads at the edge and forward to object storage

Handle file uploads at the closest PoP and stream them to storage without sending the upload through your backend.

Cold start~4ms
RuntimeWebAssembly
Fileupload.ts
upload.ts~4ms
// FastEdge — S3 Uploader
import { S3Client } from "fastedge:s3";

export default async function handler(req: Request) {
  const key  = new URL(req.url).pathname.slice(1);
  const body = await req.arrayBuffer();

  const s3 = new S3Client({
    bucket: "my-edge-bucket",
    region: "us-east-1",
  });

  await s3.put(key, body);
  return new Response("uploaded", { status: 201 });
}
Custom routing

Build custom DNS-over-HTTP logic at the edge

Resolve queries, apply overrides, or route by region from a single edge function.

Cold start~1ms
RuntimeWebAssembly
Filedns.ts
dns.ts~1ms
// FastEdge — DNS Resolver
import { dns } from "fastedge:dns";

export default async function handler(req: Request) {
  const url  = new URL(req.url);
  const host = url.searchParams.get("host") ?? "";

  const records = await dns.resolve(host, "A");

  return Response.json({ host, records, ttl: 300 });
}
Serverless generation

Generate PDF documents on demand, without a server

Render PDFs from a template and request data directly at the edge. No backend, no lambda, no queue — just a function that returns a file.

Cold start~8ms
RuntimeWebAssembly
Filepdf.ts
pdf.ts~8ms
// FastEdge — PDF Generator
import { pdf } from "fastedge:pdf";
import { template } from "./invoice.template";

export default async function handler(req: Request) {
  const data = await req.json();

  const doc = await pdf.render(template, data);

  return new Response(doc, {
    headers: {
      "content-type": "application/pdf",
      "content-disposition": 'attachment; filename="invoice.pdf"',
    },
  });
}

Free to build. Usage-based to scale.

Start with a free edge app, then scale based on the compute and edge data your application actually uses.

PRO PLAN
5€/month

plus usage-based overages

  • 3M FastEdge calls included
  • 5s runtime duration per call
  • 200 MB memory per call
  • 10M Edge Storage read requests
  • 10 MB included write size
  • Usage-based pricing beyond included limits

Need custom limits or migration support?

Plan high-volume workloads, custom usage, and advanced architecture needs.

Talk to an expert

Built for real traffic. 
Ready for edge logic.

Because traffic still has to reach the right place even when demand spikes.

Software and cloud services
"We needed a CDN provider that could deliver enterprise-grade performance at global scale. The right partner needed proven infrastructure across all major regions and the technical capability to integrate seamlessly with our existing architecture."
Headshot of a smiling man with short brown hair and a beard, wearing a white shirt, against a light gray background.

Joey Etzier

Principal Technical Program Manager, CDN

56%
improved reliability
7%
reduced churn
Read case study →
Read the case study

Start building where requests happen

Set up DNS that resolves faster, routes smarter, and stays ready as your traffic grows.

No credit card needed · Start in 2 minutes

What to now before you build

Edge compute works best when every layer has a clear job. 

Build Choices
CDN rules are best for simple, repeatable configuration. FastEdge is for logic that needs more control, like request inspection, response changes, or conditional decisions.
Edge Storage fits when your edge logic depends on data it reads often, such as feature flags, entitlement lists, routing rules, policy data, allowlists, or blocklists.
The strongest fit is lightweight request-time logic: routing, access checks, personalization, response transformation, and origin offload close to your users.
Product Boundaries
Edge Storage is built for frequent reads and infrequent writes, not source-of-truth workflows. Writes are eventually consistent and usually replicate globally within seconds.
FastEdge can handle custom validation, allow or deny checks, and request logic. WAAP is still the productized layer for web application and API protection.
CDN remains the delivery layer for caching and traffic acceleration. FastEdge adds programmable logic when the request path needs more than standard configuration.