Tools / Akamai WAF(Web Application Firewall) Interview questions
Last updated
1. What is Akamai WAF?
Akamai WAF is a cloud-delivered web application firewall that inspects HTTP and HTTPS traffic on Akamai's edge servers before it reaches your origin. It blocks attacks such as SQL injection, cross-site scripting (XSS), command injection and file inclusion.
Today it is delivered mainly through App & API Protector. Older deployments may still run Kona Site Defender.
Because filtering happens at the edge, malicious requests are dropped close to the attacker and your origin sees far less junk traffic. There is nothing to install: you onboard your hostnames to Akamai and attach a security configuration to them.
Take quiz
Inside the application server's runtime only
On Akamai's edge servers, before the request reaches the origin
In the visitor's browser
On an appliance racked in your origin data center
A page that takes long to render on the origin
A visitor with a slow home internet connection
A user who forgot their password
A query parameter carrying a SQL injection payload
2. What is Akamai App & API Protector?
App & API Protector is Akamai's current security product for web apps and APIs. It bundles WAF, rate controls, DDoS protection and API protections, all driven by the Adaptive Security Engine.
It comes in two editions. Optional add-ons such as Bot Manager, API Security and client-side protection can be layered on.
| Edition | What it gives you |
| App & API Protector | One security configuration holding all protections; separate security policies cover different hostnames or paths. |
| With Advanced Security Management | Multiple security configurations, for example one per business unit, domain or environment. |
Take quiz
App & API Protector with Advanced Security Management
The standard App & API Protector edition
Akamai Image & Video Manager
Akamai Site Shield
The origin server's application firewall
A Property Manager rule tree
The Adaptive Security Engine
An EdgeWorkers JavaScript function
3. What are the main threats Akamai WAF protects against?
Akamai WAF covers the classic application-layer attack classes, grouped as attack groups. The usual interview answer maps to the OWASP Top 10.
- Injection: SQL injection, command injection, PHP injection.
- Cross-site scripting (XSS).
- File inclusion: local (LFI) and remote (RFI).
- Attack tools and scanners hitting your site.
- Protocol and platform abuse, such as malformed requests.
- Application-layer DoS, handled through rate controls and slow POST protection.
- Data leakage in responses, through the outbound checks.
Heavy bot abuse such as credential stuffing and scraping is usually handled by the separate Bot Manager add-on.
Take quiz
Phishing emails and weak Wi-Fi passwords
Disk fragmentation and memory leaks
SQL injection and cross-site scripting
Cross-site scripting
Local file inclusion
SQL injection
Slow POST
4. What is a security configuration in Akamai?
A security configuration is the top-level container for your Akamai web security setup. It holds the hostnames you protect, your security policies, custom rules, match targets and the rate policies they use.
Each configuration is versioned. You edit a new version, activate it to the staging network to test, then activate it to production. Edits do not affect live traffic until activation.
The security configuration runs before your delivery configuration (the property in Property Manager) when a request arrives.
Take quiz
Only the TLS certificate for the site
CDN cache TTL values only
Origin server operating system patches
Hostnames, security policies, custom rules and match targets
The origin server must be restarted
It must be activated on the target network
Nothing, edits are live as soon as you save
DNS must be flushed on every visitor's device
5. What is a security policy in Akamai WAF?
A security policy is a bundle of protections applied to a defined slice of traffic. It holds the WAF mode, attack group actions, rate controls, IP/Geo firewall settings, reputation and slow POST settings.
A default policy is created automatically with every security configuration. You can clone it to build stricter or looser variants.
Typical split: a strict policy for /login and /api, and a lighter one for static marketing pages. Match targets decide which policy handles which request.
Cloning an existing policy is the quickest way to create a variant, since it copies every current setting and you only change what differs.
Take quiz
Because a policy can hold only one rule
To lower DNS TTL values
To protect /login and /api more strictly than static content
To store origin credentials safely
Automatically, when you create the security configuration
After the first attack is detected
Only when Terraform is used
After 30 days of traffic
6. What are attack groups in Akamai WAF?
Attack groups bundle WAF rules by attack vector, so you manage one setting per vector instead of hundreds of individual rules.
Typical groups include SQL Injection, Cross Site Scripting, Command Injection, Local/Remote File Inclusion, Web Attack Tool, Web Protocol Attack and Total Outbound.
You set an action (Alert, Deny and so on) per group. With the Adaptive Security Engine, rule violations inside a group combine into a risk score. You can still override individual rules when one is noisy.
Take quiz
It turns off logging for the whole policy
You manage one setting per attack vector instead of many individual rules
It removes the need for staging tests
It moves the WAF onto your origin servers
Origin Failover Group
Cache Key Group
Image Optimization Group
Web Attack Tool
7. What are the actions available in Akamai WAF?
The core actions are Alert, Deny and Deny with custom response.
| Action | Behavior |
| Alert | Logs the event and lets the request through. Used while tuning. |
| Deny | Blocks the request and returns Akamai's default block response with a reference ID. |
| Custom deny | Blocks and returns a status code, headers and body you define. |
Some features, such as rate policies, add further options depending on configuration. Start with Alert in new deployments and move to Deny once the events look clean.
Take quiz
Alert
Block and ban
Deny
Custom deny
To bypass the WAF for trusted users
To clear the edge cache
To return a branded message and chosen status code on a block
To rotate TLS keys
8. What is the Adaptive Security Engine in Akamai?
The Adaptive Security Engine (ASE) is the detection engine behind App & API Protector. It groups rules into attack groups and combines their signals into a risk score before acting.
It also correlates Akamai's platform-wide threat intelligence with data from each request, which cuts false positives compared with firing on every single rule match.
In automatic mode Akamai's researchers push engine updates for you, including rapid rules for fast-moving threats, so there is less manual tuning.
Think of it as judging a pattern rather than matching a single rule: a request that trips several related rules in one attack group is treated very differently from one that trips a single weak rule.
Take quiz
Rule violations within an attack group, as a risk score
Only the request's TCP window size
A random sample of one in ten requests
The origin server's CPU load
Manual mode
Offline mode
Automatic mode
Staging-only mode
9. What is the Kona Rule Set (KRS)?
The Kona Rule Set (KRS) is Akamai's older managed WAF ruleset, used with Kona Site Defender. It is a library of individual rules with numeric IDs, grouped into attack groups.
KRS uses anomaly scoring: each rule hit adds to a score for the group, and the group's action fires when the score crosses a threshold.
KRS is versioned. You read the release notes, test the new version and upgrade it yourself, so you decide when changes reach production.
Because decisions are rule by rule, teams on KRS usually spend more time on exceptions per rule ID than teams on the newer engine.
Take quiz
It blocks every request from a new IP
It waits for the origin to return an error
It checks the TLS certificate expiry date
Rule hits add to an anomaly score that must pass a threshold
They require replacing the origin load balancer
You review, test and apply the new version manually
They are installed from the visitor's browser
Akamai upgrades it silently every hour with no choice
10. What is Akamai Security Center?
Security Center is the part of Akamai Control Center where you manage security configurations and watch what they are doing.
It offers dashboards and trend views, a Security Events viewer showing which rules fired and for which clients, tuning recommendations and activation controls.
It is the first stop when triaging a block or an attack. For long retention and cross-system correlation, stream the same events to a SIEM.
Access is role based, so analysts can be given read-only views of events while only a few people can edit and activate configurations.
Take quiz
The Property Manager rule tree
Image & Video Manager settings
The Security Events view in Security Center
The billing usage page
A SIEM fed by Akamai's SIEM integration
Browser developer tools
The block page shown to visitors
The origin's cache headers
11. Describe how traffic reaches Akamai WAF?
Visitors resolve your hostname through DNS to an Akamai edge hostname (a CNAME such as www.example.com.edgekey.net). Their request therefore lands on an Akamai edge server instead of your origin.
At the edge, the activated security configuration is evaluated first. Only clean requests continue to the delivery configuration, then to cache or origin.
flowchart LR
A[Visitor] --> B["DNS CNAME to Akamai edge hostname"]
B --> C["Akamai edge server"]
C --> D{Security configuration}
D -- Denied --> E["Block response with reference ID"]
D -- Allowed --> F["Delivery configuration"]
F --> G["Cache or origin"]
Take quiz
They always run in parallel
The security configuration
The origin's own firewall
The delivery configuration
It turns on caching of POST requests
It removes the need for activation
It encrypts the origin database
It sends client traffic to Akamai's edge where protections apply
12. What is rate limiting in Akamai?
Akamai rate limiting caps how many requests a client can send. It protects against application-layer floods, brute-force logins and scraping.
It has two parts. A rate policy defines what to count: path, method, hostnames and the client identifier (IP, IP plus user agent, or a cookie). Rate controls then set the action per security policy, such as Alert or Deny.
Each policy carries a burst and an average threshold, covered in a later question.
Always begin in Alert mode and compare logged hits with real traffic before switching to Deny. A threshold set too low will block real users who share an IP, such as an office or a mobile carrier.
Take quiz
How long images stay in cache
Which requests to count and the thresholds for them
Which DNS servers to use
Which TLS ciphers the origin supports
Changing origin SSL certificates
Compressing JPEG images
Rewriting HTML titles
Limiting POST requests to a login endpoint per client
13. What are network lists in Akamai?
Network lists are reusable lists you define once and reference from many places. They can hold IP addresses and CIDR ranges, geographic locations (countries) and ASNs.
Akamai also publishes some managed lists, such as Tor exit nodes. Network lists feed the IP/Geo firewall, custom rule conditions and exceptions, and they can be updated through the API.
Example: keep a Corporate_VPN list and reference it in a rule that restricts /admin. When the VPN range changes, edit the list once.
Take quiz
One list can be reused across firewall settings, rules and exceptions
It stores user passwords
It replaces the need for DNS
It encrypts traffic between edge servers
Database schemas
Cache purge tokens
Country-level geographic locations
HTML page templates
14. What is the IP/Geo Firewall in Akamai?
The IP/Geo Firewall is a network-level control that allows or blocks traffic by IP address, CIDR range, country or ASN, using network lists.
You can block specific lists (deny approach) or restrict access to listed sources only (allow approach). It acts before the deeper WAF inspection, so unwanted traffic is cheap to drop.
Be careful with allow lists. Depending on configuration, trusted clients may skip later checks, so keep them narrow.
Common uses are blocking countries you do not serve, blocking a known abusive range, or limiting an admin path to office addresses. Geography is only as accurate as the underlying IP data, and VPNs can defeat it.
Take quiz
The browser's installed fonts
The SQL query inside the request body
The size of the HTML page
The client's IP, CIDR range, country or ASN
They slow down DNS lookups
Trusted clients may bypass later protections
They reset rate counters hourly
They disable HTTPS
15. What is a custom rule in Akamai WAF?
A custom rule is a rule you write yourself. It has match conditions and an action. Conditions can look at the path, method, headers, query parameters, cookies, client IP or network list, geography and more, combined with AND/OR logic.
Use custom rules for logic that managed rules cannot know, such as business-specific paths, emergency virtual patches or blocking a known bad header value.
| Condition | Example |
| Path | /admin/* |
| Method | POST |
| Client IP | Not in Corporate_VPN list |
| Action | Deny |
Give each rule a clear name and tag, because a bare rule ID means little to the next engineer reading the events. Start in Alert when the condition is new.
Take quiz
For editing DNS records
For compressing responses
For application-specific logic or a quick virtual patch
For replacing the Adaptive Security Engine
An action such as Alert or Deny
A database connection string
A browser plugin
A CDN purge schedule
16. What is the Akamai penalty box?
The penalty box temporarily holds a client that has tripped a protection, so that follow-up requests from that client get the penalty action even when they look harmless.
For rate policies, a client that violates a Deny rate control goes into the penalty box for a documented default of 10 minutes. Automated attack groups have a similar penalty box for clients that keep triggering group denies.
This stops attackers probing again and again with small variations.
It is a short-lived penalty rather than a permanent ban, so a legitimate user who triggered it once gets back in when the period ends.
Take quiz
Turns off logging for that client
Permanently deletes the client's IP from DNS
Applies the penalty action to its follow-up requests for a period
Moves the client to a faster cache
10 minutes
10 seconds
7 days
24 hours
17. What is client reputation in Akamai?
Client reputation scores an IP address based on how it has behaved across Akamai's platform. Scores reflect categories such as web attackers, DoS attackers and scanning tools.
A reputation profile sets a threshold per category and an action (Alert or Deny) for clients above it. It lets you stop known-bad clients before they send a payload your rules would catch.
Availability depends on your product edition and contract.
Because it is based on past behavior, it can flag a client on its very first request to your site, which payload-based rules cannot do. Shared IPs such as large corporate or mobile gateways can score badly through no fault of one user, so begin with Alert.
Take quiz
How old the SSL certificate is
How an IP has behaved across Akamai's platform
How large the origin's disk is
How fast the visitor's browser renders pages
A cache key with a path
A DNS record with a TTL
A TLS cipher with a version
A threshold per category with an action
18. What is Slow POST protection in Akamai?
A Slow POST attack opens connections and sends the request body extremely slowly, tying up server resources.
Akamai's protection watches the body transfer rate. If a client stays below a configured slow rate threshold for a given duration, the configured action fires, either Alert or aborting the connection.
A first-byte timeout can also be set. Tune thresholds against legitimate slow mobile clients before enforcing.
Any site with forms, uploads or APIs that accept POST bodies is exposed, since those are the connections an attacker can hold open. Genuine slow clients on poor mobile networks look similar, so review alerts before you abort connections.
Take quiz
Sends the request body very slowly to hold connections open
Replaces the TLS certificate
Injects SQL in a cookie
Floods the network with huge UDP packets
The number of DNS records
The cache TTL
The slow rate threshold over a duration
The origin's HTTP version
19. What is a WAF exception in Akamai?
An exception tells the WAF to skip a rule or attack group for requests that match certain conditions. It is the standard fix for false positives.
Good exceptions are narrow. For example, exempt one specific request parameter on one path from one rule, instead of switching the whole attack group to Alert.
Broad exceptions create blind spots attackers can use, so keep them specific and review them from time to time.
Exceptions can also be conditional, for example applying only when a given header or path matches. Record the reason and the date so the next review knows why a gap exists.
Take quiz
To speed up DNS resolution
To change the origin's IP address
To delete the security configuration
To fix a false positive for specific matching requests
Disable the whole attack group for all traffic
Exempt one parameter on one path from one rule
Turn the WAF off in production
Allow every request from any country
20. What are match targets in Akamai?
Match targets decide which security policy applies to a request. They match on hostnames and on request characteristics such as path, file extension and method.
When a request matches a target, the policy attached to that target is used. A default target typically catches everything else.
Example: one target for /api/* pointing to a strict API policy, another for *.jpg pointing to a lighter static policy.
If targets overlap, check how your configuration orders them before relying on a specific one. A handful of well-named targets is easier to audit than dozens.
Take quiz
Which origin database is used
How often logs are rotated
Which TLS version the visitor needs
Which security policy handles a given request
A browser extension
A stricter security policy for API traffic
A cache purge job
A DNS zone transfer
21. What is Akamai Site Shield?
Site Shield narrows the set of Akamai IP addresses that may contact your origin to a small, fixed map. You then allow only those IPs in your origin firewall.
This stops attackers who learn your origin's IP from hitting it directly and skipping the WAF.
It is a separate product that complements the WAF. A WAF protects nothing if the origin accepts traffic from anywhere.
When Akamai updates the Site Shield map, the origin firewall must be updated too, so subscribe to change notifications and apply them within the stated window.
Take quiz
Browser cache poisoning on visitors' laptops
Slow images
Attackers reaching the origin directly and bypassing Akamai
Expired DNS records
Allow only the Site Shield IPs in the origin firewall
Open all ports to the internet
Disable HTTPS
Remove the load balancer
22. What is attack payload logging in Akamai?
Attack payload logging records request details, headers and body portions for requests that trigger WAF rules. It shows exactly what the client sent.
It helps you confirm real attacks and diagnose false positives, because the matched data is visible instead of guessed.
Payloads can contain personal or sensitive data. Enable it only where needed and restrict who can view the logs.
A practical habit is to turn it on for one policy while you tune, then ask whether you still need it afterwards. Logging payloads for all traffic is rarely worth the storage cost or privacy exposure.
Take quiz
To rename the hostname
To see exactly what a flagged request contained
To speed up cache hits
To reduce TLS handshake time
They disable the WAF
They change DNS TTLs
They delete the origin logs
They may contain personal or sensitive data
23. What is evaluation mode in Akamai WAF?
Evaluation mode lets you test new rules, attack groups or a new ruleset version against live traffic without enforcing them.
Matches show up as evaluation events. You review them for false positives, add exceptions and only then promote the changes to enforcement.
It gives real traffic results without the risk of blocking real customers, which staging tests cannot give you.
A good rhythm is to put a newly released engine rule or attack group into evaluation, let it run through at least one busy period, add exceptions, and only then enforce it.
Take quiz
They are logged as evaluation events but not enforced
They delete the rule
They restart the edge server
They immediately block the client
It encrypts logs
It removes the need for security configurations
You see how rules react to real production traffic
It lowers rate thresholds
24. Explain the order in which Akamai evaluates protections for a request?
A request meets the security configuration at the edge and passes through protections in a set order. Broadly: network-level controls (IP/Geo firewall) first, then custom rules, rate controls, slow POST and reputation checks, then the WAF attack groups.
If a protection denies the request, evaluation stops there and the client receives the block response. Clean requests continue to the delivery configuration and the origin.
Outbound checks can then inspect the response. The exact ordering and bypass behavior depend on your edition and settings, so confirm against Akamai's Request Evaluation documentation.
flowchart TD A["Request at edge"] --> B["IP/Geo firewall"] B --> C["Custom rules, rate controls, slow POST, reputation"] C --> D["WAF attack groups and risk scoring"] D -- Deny --> X["Block response"] D -- Allow --> E["Delivery configuration"] E --> F["Cache or origin"] F --> G["Outbound response checks"]
Take quiz
The IP/Geo firewall
Origin caching
Attack group risk scoring
Outbound response checks
The rule is deleted
The request still reaches the origin
Evaluation stops and the client gets the block response
The request is retried three times
25. How does risk scoring work in Akamai WAF?
In the Adaptive Security Engine, rule violations inside an attack group add up to a risk score for that group. The engine applies the group's action only when the combined evidence is strong enough.
So one weak, low-confidence match may just be logged, while several correlated violations in the same request trigger the Deny. This is what keeps false positives down compared with acting on every single rule hit.
The engine also folds in Akamai's threat intelligence and request metadata. If you set an action on an individual rule, it works separately from the score-based decision.
In practice, a form field that happens to contain the word SELECT may add a little to the score and the request still passes. A real injection attempt usually trips several related rules at once, so the group action fires. Review events to see which requests came close to triggering.
Take quiz
Blocks the origin server
Deletes the older violations
Resets the DNS cache
Combines them into a risk score for the group
It ignores request headers
A single weak match does not automatically trigger a Deny
It allows all POST requests
It disables rules at random
26. Why use automatic mode for Adaptive Security Engine updates?
Automatic mode lets Akamai upgrade the engine for you, so new detections and rapid rules for fresh threats reach your policies without a manual project. Akamai recommends it for most teams.
| Automatic mode | Manual mode | |
| Updates | Applied by Akamai regularly | You schedule and apply them |
| Effort | Low | Higher: review, test, upgrade |
| Risk | Faster protection, less control over timing | Slower protection, full control over timing |
| Fits | Most teams | Strict change-freeze or regulated environments |
If change control worries you, keep automatic mode and watch new detections in Alert or evaluation first, instead of falling behind on protection.
A sensible middle path is automatic mode plus evaluation mode for anything new, and a quick weekly look at what changed. You keep the speed of Akamai's updates and still get a chance to catch surprises before they are enforced.
Take quiz
It makes the origin faster
It disables logging
New protections arrive without a manual upgrade project
It removes the need for a security configuration
One with a strict change-freeze or regulatory approval step
A small blog with no change process
A site that only serves images
A site with no traffic at all
27. How do you onboard a new hostname to Akamai WAF?
Onboarding means getting the hostname onto Akamai and then attaching a security configuration. A safe order:
- Create or update the property in Property Manager with the hostname and an edge hostname (for example
.edgekey.netwith a TLS certificate). - Add the hostname to your security configuration and make sure a match target and policy cover it.
- Set attack groups to Alert at first.
- Activate the property and security configuration on staging and test.
- Activate on production, then point DNS at the edge hostname with a CNAME.
- Review security events, add narrow exceptions and move groups to Deny.
flowchart LR A["Property and edge hostname"] --> B["Add hostname to security config"] B --> C["Policy in Alert mode"] C --> D["Activate on staging and test"] D --> E["Activate on production"] E --> F["DNS CNAME to edge hostname"] F --> G["Tune then move to Deny"]
Take quiz
Deny for everything on day one
Alert, until events are reviewed
Disabled permanently
Randomly alternating
A TXT record with the WAF mode
An MX record to the origin
A reverse PTR record only
A CNAME from the hostname to the Akamai edge hostname
28. How do you test Akamai WAF changes on the staging network?
Activate the configuration to staging, then send requests to the staging edge instead of production. Resolve the staging edge hostname (the edgekey-staging.net variant of your edge hostname) and force your test client to use it.
dig www.example.com.edgekey-staging.net +short curl -ik --resolve www.example.com:443:<staging-ip> \ "https://www.example.com/search?q=1%27%20OR%20%271%27=%271"
Check the response for the block page and its reference ID, then look the event up. Test both attack payloads (should block) and normal traffic (should pass).
Staging confirms rule behavior, but it does not reproduce production traffic volume or rate limits.
Keep a small regression list of requests, one clean one and a few attack samples per attack group, and rerun it after every change. Remember that staging has to be activated for both the property and the security configuration, otherwise you may be testing old settings.
Take quiz
Edit the origin's firewall
Force resolution with curl --resolve or a hosts file entry
Change the TLS certificate
Purge the production cache
Whether a normal request passes
Whether the block page appears
Whether a SQL injection payload is blocked
Real production traffic volume and rate behavior
29. How do you troubleshoot a false positive blocked by Akamai WAF?
A repeatable approach:
- Get the reference ID from the user's block page.
- Look it up in Security Events and note the attack group, rule and the matched field (for example a query parameter).
- Reproduce it on staging with the same request.
- Decide the narrowest fix: an exception for that rule on that parameter or path, not a group-wide downgrade.
- Test on staging, activate to production and re-check the event feed.
- Document the exception and why it exists, so it can be reviewed later.
If the same rule keeps firing on legitimate traffic, check the tuning recommendations too.
Typical culprits are rich-text editors, search boxes that accept symbols, JSON bodies that hold code snippets and third-party webhooks with unusual encodings. Those flows are good candidates for narrow exceptions on the specific field.
Take quiz
The reference ID shown on the block page
The origin's CPU graph
Their home address
Their browser history
Turning off the WAF entirely
Deleting the security configuration
A narrow exception for the specific rule and field
Allowing all traffic from the user's country
30. How do you read an Akamai WAF security event?
A security event shows who sent what and why it was flagged. Key fields to read:
- Client IP, geography and ASN.
- Hostname, path and method.
- Triggered rules with rule IDs and messages, and the attack group.
- Matched data or selector, such as the parameter that held the payload.
- Action taken (Alert, Deny) and the policy that applied.
- Client reputation or rate details when those protections fired.
In SIEM output the attack data fields are encoded, so decode them before reading rule IDs and messages. Start with the matched data: it usually tells you straight away whether the hit was an attack or a false positive.
Compare several events from the same client. One noisy match is often a false positive, while a spread of different attack groups from one IP within a few minutes looks like scanning.
Take quiz
The cache hit ratio
The DNS TTL
The origin's TLS version
The matched data or selector
Because they are the only copy of the logs
Rule details are encoded and unreadable otherwise
Because they hold the WAF license key
Because decoding blocks the client
31. How do you configure a rate policy to protect a login endpoint?
The goal is to slow credential guessing without hurting real users.
- Create a rate policy that matches the login path and the POST method.
- Pick the client identifier: IP, or IP plus user agent for better precision. A cookie identifier tracks a session even if the IP changes.
- Set thresholds from your real traffic. A small start such as average 3, burst 5 hits per second can be tuned.
- Attach it to the security policy via rate controls with Alert first.
- After reviewing events, switch the action to Deny or a custom deny such as 429.
Per-IP counting does not catch attacks spread across thousands of IPs. For credential stuffing at that scale add Bot Manager.
Choose the response with care. A plain block tells a script exactly what to avoid, while a clear 429 or a slower response discourages it. Re-check thresholds after marketing campaigns, because legitimate retries spike then.
Take quiz
The image size and DNS TTL
The origin OS and disk type
The login path and the POST method
The TLS cipher and cache key
The attack is spread across many different IPs
Because rate limits only work for GET
Because IPs cannot be counted
Because the WAF ignores logins
32. What is the difference between burst and average thresholds in Akamai rate policies?
Both are measured in hits per second, but over different windows. A client tripping either one violates the policy.
| Threshold | Window | Catches |
| Burst | 1 to 5 seconds (5 is the usual default) | Sudden spikes and fast floods |
| Average | 2 minutes | Sustained, slower abuse |
Akamai advises caution before shrinking the burst window on an existing policy. Test it in Alert mode first, because shorter windows are more sensitive to normal spikes.
Example: with average 3 and burst 5, a client sending 8 requests per second for five seconds trips the burst threshold. A client sending 4 per second for several minutes stays under burst but eventually trips the average. A client sending 2 per second trips neither. Set burst above average, because real users click in short bursts.
Take quiz
Twenty-four hours
Thirty days
Two minutes
One second
Burst
Slow POST
Reputation
Average
33. What is the difference between KRS and the Adaptive Security Engine?
KRS is the older ruleset model. The Adaptive Security Engine is the newer model behind App & API Protector.
| Aspect | KRS | Adaptive Security Engine |
| Model | Individual rules with anomaly scores and thresholds | Attack groups with risk scoring and adaptive detections |
| Updates | Versioned, upgraded manually | Automatic updates, with a manual option |
| Tuning effort | Higher, more rule-level work | Lower, less manual tuning |
| Typical product | Kona Site Defender | App & API Protector |
Both can be tuned with exceptions. The main shift is from managing rules to managing outcomes per attack group.
In an interview, say the shift is mainly about effort and automation: you stop triaging individual rule IDs and start deciding what to do about an attack vector. KRS knowledge is still useful, because many exceptions and event fields look similar.
Take quiz
Image & Video Manager
Kona Site Defender
Site Shield
App & API Protector only
Only through a visitor's browser
Never, the engine is static
By email attachments each month
Automatically by Akamai, with manual as an option
34. What is the difference between App & API Protector and Kona Site Defender?
Kona Site Defender is the earlier WAF and DDoS product built around KRS. App & API Protector is its successor, built on the Adaptive Security Engine.
| Aspect | Kona Site Defender | App & API Protector |
| Engine | KRS rules and anomaly scoring | Adaptive Security Engine |
| Management | More manual rule and match target work | Simplified with presets and automation |
| Scope | Web application and DDoS protection | WAF, API, DDoS and optional bot and client-side add-ons |
| Updates | Upgrade KRS versions yourself | Automatic updates recommended |
Akamai positions App & API Protector for new deployments, and Kona customers migrate over time.
Existing Kona customers typically keep their KRS-based setup running while they plan a move. Migration is mostly re-creating policies, exceptions and custom rules, then testing them in evaluation mode.
Take quiz
The Adaptive Security Engine
A browser-side engine
An origin-side module
KRS only
Mandatory manual rule writing
Moving the WAF onto the origin
Simplified management with more automation
Removal of all logging
35. What is the difference between Akamai WAF and Bot Manager?
The WAF looks at what a request contains. Bot Manager looks at who or what is sending it.
| WAF | Bot Manager | |
| Focus | Malicious payloads and protocol abuse | Automated clients and abuse of valid requests |
| Examples | SQL injection, XSS, file inclusion | Credential stuffing, scraping, inventory hoarding |
| Signals | Rules, risk scores, reputation | Bot classification, behavior and client signals |
A credential-stuffing request can be perfectly valid HTTP, so the WAF may see nothing wrong. That is why serious sites run both.
Many teams run them together: WAF rules and rate limits cover the application paths, while Bot Manager adds classification and a range of responses on login, checkout and search pages. Start by looking at which flows are abused and match the tool to that abuse.
Take quiz
Only the SQL Injection attack group
Site Shield
Property Manager caching rules
Bot Manager
The origin's disk usage
The contents of the request, such as payloads
The DNS zone file
The visitor's mouse movements only
36. How should you roll out a new WAF policy safely?
Move from observation to enforcement in steps, never straight to Deny.
- Create the policy with attack groups in Alert.
- Run it for a full business cycle (often one to two weeks) so rare flows such as month-end jobs show up.
- Review the top triggered rules and add narrow exceptions.
- Move high-confidence groups such as SQL injection and command injection to Deny first.
- Handle rate policies the same way: Alert, review, then Deny.
- Keep the previous version ready for rollback and monitor events after each change.
Use evaluation mode for new engine rules before they are enforced.
Write down the rollback plan and an owner before each activation, and tell application teams the enforcement date so support does not learn about blocks from customers first.
Take quiz
Custom deny with a 500 status
Deny for every group
Disabled
Alert
Only the outbound group
High-confidence ones such as SQL injection and command injection
None, Deny is never used
Every group at the same time
37. How does Akamai WAF inspect JSON and XML API payloads?
For API traffic the engine parses JSON and XML request bodies, so rules see individual keys and values instead of one opaque blob. A SQL injection string inside a JSON field can then match an attack group.
The inspection depends on a correct Content-Type and on the body fitting within the configured request body inspection limit.
For tighter control, add API-specific protection: define endpoints, expected methods and parameters, and apply rate policies per endpoint.
Example: a signup API receives {"comment": "1' OR '1'='1"}. Because the body is parsed, the engine sees the value of comment and can score it under the SQL injection group instead of ignoring it. Deeply nested or very large documents are where gaps appear, so test with realistic payload sizes.
Take quiz
It makes JSON smaller on the wire
It caches API responses forever
Rules can examine individual JSON keys and values
It removes the need for authentication
A correct Content-Type and a body within the inspection limit
The origin's CPU model
The visitor's screen size
The DNS provider
38. How does the request body inspection size limit affect WAF coverage?
The WAF inspects only up to a set request body inspection size limit (commonly 8 KB by default and adjustable up to 32 KB, depending on edition). Anything beyond that point is not inspected.
An attacker can try to bury a payload past the limit by padding the body with junk first. APIs and form posts that carry large bodies are most exposed.
Raise the limit where large bodies are legitimate, accept the small extra processing cost, and pair it with request size limits at the origin. Check the limit in your own configuration, since defaults vary.
Check your events for requests that exceeded the limit, if your edition reports them, and decide per policy whether oversized bodies should alert or deny.
Take quiz
It is always blocked
It is not inspected by the body rules
It is encrypted twice
It is cached for a week
By changing the DNS zone
By renaming the hostname
By editing the WAF rules remotely
By padding the body so the payload sits past the limit
39. When should you use custom rules instead of managed rules?
Managed rules (attack groups) cover generic attack classes. Use custom rules when the logic is specific to you.
| Use managed rules for | Use custom rules for |
| SQL injection, XSS, file inclusion and other generic patterns | Blocking or allowing specific paths, headers, methods or networks |
| Broad coverage that Akamai keeps current | Emergency virtual patching of a known vulnerable endpoint |
| Low maintenance | Business-specific logic, such as restricting an admin path |
Custom rules need ownership. Name them, tag them and remove them when the underlying fix is deployed, or they pile up as hidden technical debt.
A useful test: if the logic reads like 'when this path and this header appear, do this', it is a custom rule. If it reads like 'recognize this class of attack in any parameter', leave it to the managed engine.
Take quiz
Virtual patching a specific vulnerable endpoint
Compressing images
Maintaining the Akamai threat feed
Detecting every SQL injection variant
They slow down the origin database
They disable HTTPS
They become forgotten technical debt
They expire DNS records
40. How do you build a custom rule to restrict an admin path?
Goal: only the corporate VPN may reach /admin. Build it from three pieces:
| Part | Setting |
| Condition 1 | Request path matches /admin/* |
| Condition 2 (AND) | Client IP is not in the Corporate_VPN network list |
| Action | Deny (or a custom deny with a clear message) |
Both conditions must be true for the rule to fire, so a VPN user passes and everyone else is blocked. Test on staging with an IP outside the list, then activate.
Using a network list means VPN range changes need only a list edit, not a rule edit.
A rule created in the configuration still has to be added to the right policy with an action before it runs. Start in Alert to confirm VPN users are not caught by a stale list.
Take quiz
With AND, so both must be true
With OR, so either one blocks everyone
Neither, conditions are ignored
With XOR on the TLS version
It turns the WAF off for admins
It disables Deny actions
Range changes need only a list edit, not a rule edit
It encrypts the VPN traffic
41. How do you integrate Akamai WAF logs with a SIEM?
Use Akamai's SIEM integration feature. It exposes security events through a pull-based API, and ready-made connectors exist for tools such as Splunk, QRadar and Microsoft Sentinel.
- Enable SIEM integration on the security configuration and choose which policies to include.
- Create an API client (EdgeGrid credentials) with access to the SIEM API.
- Configure the connector or collector to poll with an offset, so no events are missed or duplicated.
- Decode the encoded attack data fields (rule IDs, messages, matched data) in your pipeline.
- Build alerts and dashboards on rule, client and hostname.
Expect a short delay between an event and its arrival, so do not rely on it for per-second reactions.
Watch the volume. A busy site can produce a lot of events, so filter by policy or attack group, and consider sampling Alert-only events before they reach expensive storage.
Take quiz
To pick a random edge server
To rotate the TLS certificate
To encrypt the events
To avoid missing or duplicating events
Rename the hostname
Decode the encoded attack data fields
Delete them to save space
Convert them into DNS records
42. How do you preserve the real client IP behind Akamai?
Your origin sees Akamai's edge IPs as the connecting address. To get the visitor's IP, enable the True-Client-IP header in the property. Akamai also appends the client address to X-Forwarded-For.
Your application and logs should read the header, but only trust it when the request truly came from Akamai. Restrict the origin to Akamai's IPs with Site Shield, otherwise anyone can forge the header.
If another proxy or CDN sits in front of Akamai, rate policies can be told to use the X-Forwarded-For contents, so limits apply to the real client and not the front proxy.
If your application logs show only Akamai addresses, the header is either not enabled in the property or not being read by your application.
Take quiz
Cache-Control
ETag
True-Client-IP
Accept-Language
So attackers cannot forge the header by hitting the origin directly
To speed up TLS handshakes
To rename the hostname
To enable caching of POST
43. How does Akamai protect against application-layer DDoS attacks?
Akamai absorbs volumetric traffic across its large distributed edge, so floods are spread out and do not converge on your origin.
For application-layer (Layer 7) floods, you add specific controls on top of that:
| Layer | Typical control |
| Network (L3/L4) | Absorbed by the edge platform; large scrubbing needs may use the separate Prolexic service |
| Application (L7) | Rate policies, slow POST protection, penalty box, client reputation, WAF attack groups, geo or network list blocks |
Caching static and cacheable content also reduces what reaches the origin during an attack.
No single control stops everything. A typical response is to confirm the pattern in Security Events, tighten the rate policy for the abused path, block the offending networks, and contact Akamai support if the attack is large. Practice that flow before you need it.
Take quiz
TLS certificate pinning
Rate policies
Image compression
Origin database indexing
It disables DNS
It encrypts all attack traffic
It blocks all POST requests
Cacheable requests are served at the edge, not the origin
44. What happens when a client exceeds an Akamai rate policy threshold?
When a client crosses the burst or average threshold, the rate control's action applies. With Alert the event is only logged. With Deny the request is blocked.
A denied client also goes into the penalty box (a documented default of 10 minutes for per-edge counting), so follow-up requests get the same treatment for that period.
You can use a custom deny to return a clearer response, such as 429 Too Many Requests with a Retry-After header. Counting can be per edge or aggregated across a region, which changes how quickly a distributed client is caught.
Counting scope matters. Per-edge counters only see traffic reaching one edge server, so an attacker spread across many edges may stay under the limit, while region-aggregated counting pools those requests together.
Take quiz
Blocks the client forever
Logs the event without blocking
Changes the origin IP
Reboots the edge server
A 301 to a random site
A 200 with the full page
An empty TCP reset only
A custom deny such as 429 with Retry-After
45. How does Akamai WAF detect data leakage in responses?
Besides inspecting requests, Akamai can check outbound responses. The outbound attack group looks for signs of leakage, such as database error messages, stack traces, directory listings or server version details.
These responses often appear when an attack partly succeeds, so seeing them is a useful alarm. Outbound checks can raise an alert or block the response, depending on the action you set.
Start in Alert, because verbose error pages on legitimate flows can produce false positives. The real fix is still hiding errors in the application.
Typical leaks are a visible SQL error after a malformed parameter, a framework debug page or a stack trace with file paths. Any of these tells an attacker which database or framework you run, which is why alerting on them is valuable.
Take quiz
Error messages, stack traces and directory listings
DNS TTL values
Image dimensions
The visitor's browser cookies only
Because outbound checks run on the visitor's PC
Because Deny is unavailable
Legitimate verbose pages can cause false positives
Because Alert encrypts responses
46. How do tuning recommendations help in Akamai WAF?
Akamai analyzes your security events and suggests exceptions for rules or attack groups that look like false positives, for example a specific parameter that triggers a rule on legitimate traffic.
- Open the recommendations for an attack group or rule.
- Read the evidence, such as the matched parameter and how often it fired.
- Accept it to create the exception, or ignore it.
- Activate on staging, then production.
You can also subscribe to recommendation emails. Always review before accepting, because a suggestion built from traffic that contained a real attack could hide it.
Treat the feature as a starting point for review, not an autopilot. Log the accepted recommendation, who approved it and when it should be re-checked.
Take quiz
Replacing the DNS provider
Disabling TLS
Rebooting the origin
Exceptions for likely false positives
Because they change the hostname
The underlying traffic might have been a real attack
Because suggestions delete logs
Because they expire immediately
47. How do you protect APIs with API discovery and constraints in Akamai?
API discovery finds the API endpoints that actually receive traffic, including ones nobody documented (shadow APIs).
Once endpoints are known, register them (for example by importing an OpenAPI definition) and apply API constraints to enforce what is expected: allowed methods, content types, parameters and body size. Requests outside the definition can be alerted or denied.
Add per-endpoint rate policies and the WAF attack groups on top. The result is a positive security model (allow what you defined) plus signature-style detection.
Start in Alert so you can see what real clients send. Mobile apps and partners often use endpoints that the documentation never mentioned, so enforcing a constraint on day one can break them. Update the definition whenever a new API version ships.
Take quiz
Origin disk errors
Browser plugins
Endpoints receiving traffic, including undocumented ones
Expired TLS certificates only
That requests match the expected method, content type and parameters
That cookies are always blank
That every response is cached
That DNS has two records
48. Which is better and why: Akamai WAF or AWS WAF?
Neither wins everywhere. The better fit depends on your architecture and team.
| Aspect | Akamai WAF | AWS WAF |
| Where it runs | Akamai's global edge, in front of any origin | Attached to CloudFront, ALB, API Gateway and other AWS resources |
| Rule approach | Adaptive engine with attack groups and risk scoring | Rule groups and Web ACLs, with managed groups plus your own rules |
| Add-ons | Bot, API, DDoS and client-side options in the same platform | Separate AWS services and options for bots and DDoS |
| Best fit | Multi-cloud or hybrid, large traffic, low tuning effort | AWS-centric stacks with infrastructure-as-code and in-house rule ownership |
If everything runs on AWS behind an ALB and you want native integration, AWS WAF is hard to beat. If you serve global traffic from mixed origins and want strong automation, Akamai is a strong choice.
Take quiz
A hybrid mix of data centers and clouds only
A stack with no origin
A stack fully on AWS behind an ALB or CloudFront
A site with no web traffic
A global edge in front of any origin with an adaptive engine
Native attachment to AWS ALBs only
Running inside the visitor's browser
Hosting the origin database
49. How do you manage and roll back Akamai WAF changes as code?
Every change creates a new version of the security configuration, and activations are recorded with who did what and when. To roll back, activate the last known-good version (or a clone of it).
For repeatable changes, manage the configuration with the Akamai Terraform provider or CLI and keep it in Git. A rate policy as Terraform:
resource "akamai_appsec_rate_policy" "login" { config_id = 12345 rate_policy = jsonencode({ name = "Login POST" type = "WAF" matchType = "path" pathMatchType = "Custom" pathUriPositiveMatch = true path = { positiveMatch = true, values = ["/login"] } additionalMatchOptions = [{ positiveMatch = true type = "RequestMethodCondition" values = ["POST"] }] averageThreshold = 3 burstThreshold = 5 clientIdentifiers = ["ip"] counterType = "per_edge" requestType = "ClientRequest" penaltyBoxDuration = "TEN_MINUTES" }) }
Peer-review the pull request, apply to staging, test, then production. Git history plus Akamai's activation history gives you a full audit trail.
Take quiz
Ask visitors to clear their cache
Activate the last known-good version or a clone of it
Delete the origin server
Wait for DNS to expire
It replaces the Adaptive Security Engine
It removes the need for activation
It disables staging
Reviewable, repeatable changes with an audit trail
50. How do you respond to a zero-day vulnerability using Akamai WAF?
Treat the WAF as a quick shield while the real patch is prepared.
- Check Akamai's advisories to see whether a rapid rule or engine update already covers it, and enable it (in Alert first if you can).
- If not covered, write a custom rule (virtual patch) matching the vulnerable path, parameter or header pattern, with a Deny action.
- Activate on staging, test with the exploit pattern and normal traffic.
- Activate to production and watch the events and SIEM for hits.
- Patch the application at the origin.
- After the fix and a vendor rule exist, retire the custom rule.
flowchart LR
A["Zero-day disclosed"] --> B{Rapid rule or update available?}
B -- Yes --> C["Enable it"]
B -- No --> D["Write custom virtual patch rule"]
D --> E["Test on staging"]
C --> E
E --> F["Activate on production"]
F --> G["Monitor events"]
G --> H["Patch origin and retire custom rule"]