Hi everyone, I’ve been testing out Imperva’s WAF for the past week as part of our migration to Azure. We have some old, legacy web apps that we’re doing a lift-and-shift on, and security was a big concern. I was really nervous about just trusting the defaults, so I ran some basic pen tests against our staging environment to see what would get through.
I used a mix of automated tools and some manual probing, focusing on common OWASP Top 10 stuff—SQLi, XSS, path traversal. I have to say, I was impressed. Out of the box, with their managed rules enabled, it blocked almost everything I threw at it. The logs in the dashboard were clear, showing exactly what rule triggered and why, which is great for my peace of mind. I could see the attack type, IP, and even a snippet of the malicious payload.
But I did run into a few false positives. One of our legacy apps has a weird query parameter format that got flagged as a cross-site scripting attempt. I had to create a custom rule to exclude that specific parameter, which was a bit intimidating at first. The process was straightforward once I found the right section, but I’m still worried about tuning it perfectly without opening a hole. Has anyone else dealt with this? How careful do you need to be with exceptions?
Overall, after a week, I feel a lot better about putting these old systems behind their WAF. The protection seems solid. My next step is to look at their DDoS features. If anyone has gone through a similar migration timeline with Imperva, I’d love to hear about your experience—especially how long it took to get everything tuned and running smoothly in production.
One step at a time
False positives are the tax you pay for a WAF that actually works. That custom rule you created for the weird parameter? That's your new attack surface. How often does that legacy app get traffic, and what's the blast radius if someone figures out the bypass?
You mentioned a migration to Azure. Have you compared the managed rule pricing to Azure's own WAF, or just running the OWASP Core Rule Set on an application gateway? The logging is nice, but I've seen teams get complacent and let the bill balloon because they never reviewed which rules were firing in production.
Show me the bill
Good point about the custom rule becoming an attack vector. Seen that exact scenario blow up when a "temporary" exception for a vendor's weird API call lived for two years. Suddenly it's the front door.
And you're dead on about the billing. It's the silent killer. The logging is great until you realize you're paying per million requests and that old, unmonitored cron job is pinging your staging URL every five minutes, triggering a dozen rules each time. The bill looks like a phone number.
Have you actually tried tuning the OWASP CRS on an Azure Gateway? Last time I did, the false positive rate was a full-time job for a week. Sometimes the managed tax is worth it.
CRM is a means, not an end.
Oh, the "temporary exception" is a classic, and you're right to call it a front door. I had a client who did that for a Salesforce Marketing Cloud connector - the exception was so broad it basically disabled SQLi detection on an entire endpoint for years. We only found it during an audit, and the team that wrote it had long since left.
Your point about the tuning being a full-time job hits home. I think that's the real calculation: is your team's time cheaper than the managed service fee? For a lot of mid-size shops without a dedicated appsec person, the answer is a painful "no." You end up with a misconfigured, noisy system and a team that learns to ignore the alerts.
The cron job billing horror story is too real. It makes a strong case for separating your staging and production WAF policies entirely, even if it's a bit more management overhead. Let staging absorb the cost of those rogue pings.
Implementation is 80% process, 20% tool.
Yeah, the "temporary exception" story is a great (and scary) example. It makes me wonder how you even start tracking those things down after the fact. Do you just do regular reviews of all the active rule exceptions, or is there a better process to flag ones that are getting old?
And I totally agree on the cost of tuning. For teams like ours without a full time security person, that managed fee starts to look a lot more like an insurance policy against our own configuration drift. The idea of separate staging/prod policies is smart, I hadn't considered that as a way to isolate the financial bleed from test traffic.
That's really encouraging to hear about the out-of-the-box coverage. I'm new to this whole security monitoring side, so seeing clear logs that actually explain the block is a huge win for me too.
About the custom rule for the weird parameter, I get the nerves. I had a similar moment with a Prometheus metric label. When you have to make an exception, how do you document it? I started taking a screenshot of the rule config and dropping it in our team's channel with a note, but that feels janky. Is there a better way to track why a rule was changed?
Impressive results, but you're celebrating on day seven. That's the honeymoon phase.
The clear logs are a feature, not a benefit. The benefit is when someone actually looks at them six months from now when you're buried in alerts. Your "peace of mind" is the vendor's primary marketing angle, and it works until your team learns to ignore the dashboard because of noise.
That custom rule for the weird parameter? That's your first step down the path. You're not "opening a hole" with a perfect tune, you're creating a documented deviation. The real risk is when you forget *why* you made it, or when the next person sees your rule and uses it as a template for their own "weird" case. How are you planning to track the business justification for that exclusion beyond a comment in the WAF console that nobody reads?
cg
A week of testing tells you nothing about maintenance. The logs are clear today. Come back when you've ignored the dashboard for three months and the alert fatigue sets in.
Your false positive isn't unique. You just created your first technical debt. Every custom rule is a future breach waiting for someone to forget why it exists. Did you write the business justification outside the WAF console, or is it lost in a Slack thread already?
Simplicity is the ultimate sophistication
I know that exact feeling with the screenshots in Slack, it feels so temporary. We started putting those decisions in our Confluence page for the project, with a little table for each exception. It helps to have a "review date" column too, so it doesn't just live forever. Still a bit manual though.
What would you recommend for making that process smoother? I wonder if there's a way to link the rule change directly to a Jira ticket.
A custom rule for a legacy parameter is the exact point where a managed WAF's cost shifts from just dollars to operational risk. The rule itself is free, but forgetting its context is where the real expense hits.
Your false positive tuning process needs a direct link to cost and risk review. When you create that exclusion, the next step shouldn't just be verifying the app works. It should be opening a ticket with the rule ID, business justification, and a hard 90-day review date attached to the Azure resource tag. That way, when you're auditing your bill or resources later, the "why" is tied to the asset.
Without that, you're not just creating a security debt, you're creating a future financial blind spot for the next person reviewing the subscription.
Less spend, more headroom.
The intimidation you felt creating that custom rule is your most important data point. That's your early warning signal for configuration drift. Clear logs are great, but their value decays without a strict process for documenting the 'why' behind each exception.
We treat WAF rule changes like a schema change in our analytics warehouse. Every custom rule or exclusion gets a corresponding ticket in our incident/change system. The ticket must contain the business justification, the specific payload or parameter pattern, and a hard review date. We even tag the Azure resource with the ticket ID.
Without that lineage, you're not managing a WAF, you're accumulating security debt. In six months, that "weird parameter" rule will be an unexplained anomaly in your config, and someone will use it as a precedent for another exception. That's how managed services become unmanaged liabilities.
Garbage in, garbage out.
You're right about the billing creep. We had that exact shock after moving to Azure's WAF - the logs were fantastic, but the cost spiked because an old, forgotten staging rule set was still processing live traffic. The managed rule pricing looked steep on paper, but it was cheaper than the engineering hours we spent finding and killing those phantom rules.
That "blast radius" question is key. We map every custom rule to a specific service or feature in our architecture diagrams now. If a legacy app gets less than 1% of traffic, its custom rule gets a much shorter review cycle. It forces us to ask if we should just refactor the app instead of permanently weakening the WAF config.
That's a sharp point about the maintenance timeline I hadn't considered. My "week of testing" was really just seeing if it worked at all, not how we'd live with it.
> lost in a Slack thread already
You've got me here. I put a note in the rule comment field, but that's it. Seeing everyone talk about Confluence pages and ticket links makes it clear how fragile that is.
How do you even start building that habit when you're just one person trying to get something unblocked? It feels like you need the process in place *before* the first false positive hits.
The clear logs are a clever distraction. You're focused on the immediate, satisfying feedback of seeing your own test attacks blocked, which is exactly what the vendor wants.
You're nervous about the custom rule's "perfect tune," but that's the wrong problem. The real issue is that you've already accepted the premise of your legacy app's broken parameter format as a permanent constraint. Every exclusion you carve out for a "weird" legacy behavior is a vote to keep that technical debt alive. The WAF shouldn't become a crutch that lets you postpone actually fixing the application.
Your peace of mind lasted exactly as long as your first false positive. Now you're in the business of exception management, which has a far steeper learning curve than clicking 'enable' on a managed ruleset.
Trust but verify.
You're absolutely right about the WAF becoming a crutch. I've seen teams use exclusions to permanently accommodate legacy API endpoints that should have been deprecated years ago. The operational cost of maintaining those carve-outs eventually exceeds the cost of a refactor, but it's never accounted for that way.
The more subtle trap is when the WAF's ability to create precise exclusions creates a false sense of security precision. You think you've surgically removed a blocking condition, but you've actually created a new, undocumented attack surface around that parameter's behavior. The "business justification" often stops at "the app works now," not "here's the security model for this parameter post-exclusion."
It's infrastructure as a policy bypass, and it gets baked in.
CPU cycles matter