Introducing FastEdge Triggers: real-time edge logic

When you're building real-time applications, whether for streaming platforms, SaaS dashboards, or security-sensitive services, you need content that adapts on the fly. Blocking suspicious IPs, injecting personalized content, transforming media on the edge—these should be fast, scalable, and reliable.

Until now, they weren't.

Developers and technical teams often had to work across multiple departments to create brittle, hardcoded solutions. Each use case, like watermarking video or rewriting headers, required a custom integration. There was no easy way to run logic dynamically at the edge. That changes with FastEdge Triggers.

Real-time logic, built into the edge

FastEdge Triggers let you execute custom serverless logic at key moments in the HTTP lifecycle:

• on_request_headers
• on_request_body
• on_response_headers
• on_response_body

FastEdge is built on the proxy-wasm standard, making it easy to adapt existing proxy-wasm applications (e.g., for Envoy or Kong) for use with Gcore. These trigger types align directly with proxy-wasm conventions, meaning less friction for developers familiar with modern proxy architectures.

This means that you can now:

• Authenticate users' tokens, such as JWT
• Block access by IP, region, or user agent
• Inject CSS, HTML, or JavaScript into responses
• Transform images or convert markdown to HTML before delivery
• Add security tokens or watermarks to video content
• Rewrite or sanitize request headers and bodies

No backend round-trips. No manual routing. Just real-time, programmable edge behavior, backed by Gcore's global infrastructure.

While FastEdge enables instant logic execution at the edge, response-stage triggers (on_response_headers and on_response_body) naturally depend on receiving data from the origin before acting. Even so, transformations happen at the edge, reducing backend load and improving overall efficiency.

Our architecture means that FastEdge logic is executed in ultra-low-latency environments, tightly coupled with CDN. Triggers can be layered across multiple stages of a request without performance degradation.

Built for developers

FastEdge Triggers were built to solve three core pain points for technical teams:

• Hard to scale: Custom logic used to require bespoke, team-specific workarounds
• Hard to maintain: Even single-team solutions became brittle without proper edge infrastructure
• Limited flexibility: Legacy CDN logic couldn't support complex, dynamic behavior

With FastEdge, developers have full control: no DevOps bottlenecks, no workarounds, no compromises. Logic runs at the edge, not your origin, minimizing backend exposure. FastEdge apps execute in isolated, sandboxed environments, reducing the risk of vulnerabilities that might otherwise be introduced when logic runs on central infrastructure.

How it works behind the scenes

Each FastEdge application is written in Rust or AssemblyScript and connected to the HTTP request lifecycle through Gcore's configuration interface. Apps are linked to trigger types through the CDN resource settings page in the Gcore Customer Portal.

Here's what happens under the hood:

1. You assign a FastEdge app to a trigger point.
2. Our Core Proxy detects that trigger and automatically routes execution through your custom logic.
3. The result is returned before hitting cache or origin, modified, enriched, and secured.

This flow is deeply integrated with our CDN service, delivering minimal latency with zero friction.

A real-life use case: markdown to HTML at the edge

Here's a real-world example that shows how FastEdge Triggers can power multi-step content transformation without a single backend server.

One customer wanted to serve Markdown-based documentation as styled HTML, without spinning up infrastructure. Using this FastEdge app written in Rust, they achieved just that.

• The app listens at three trigger points: on_request_headers, on_response_headers, and on_response_body
• It detects requests for .md files and converts them on the fly
• The HTML is served directly via CDN, no origin compute required

You can see it live here:

• README rendered
• Terraform docs rendered

This use case showcases FastEdge's ability to orchestrate multi-stage logic at the edge: ideal for serverless documentation, lightweight rendering, or content transformation pipelines.

Ready to build smarter at the edge?

FastEdge Triggers are available now for all FastEdge customers. If you're looking to modernize your edge logic, simplify architecture, and ship faster with fewer backend dependencies, FastEdge is built for you.

Reach out to your account manager or contact us to activate FastEdge Triggers in your environment.

Try Fastedge Triggers