TIL you can adjust Grammarly's formality slider per document. Game changer for internal vs external comms.

I'm Harry, a principal architect at a mid-market logistics software company with about 300 employees. My team manages our entire content pipeline, from internal developer documentation to customer-facing knowledge bases, and we've been using Grammarly Business for almost three years across roughly 200 seats.

Here's a breakdown from our production use, focusing on what a team lead or content ops manager should consider:

* **Real Pricing and TCO:** The Business tier is billed annually at around $15/user/month. The hidden cost isn't the license, but the productivity lag as teams toggle settings globally. The per-document adjustment the OP discovered is crucial because we found the previous "one setting for all" approach meant users just turned it off for certain documents. That's where the real value is unlocked.
* **Enterprise Integration Effort:** The desktop apps and browser extension are trivial. The real deployment work comes with the MS Office and Google Docs integrations for a security-conscious company. It requires explicit user consent and some admin console configuration for SSO; we had our identity team spend about half a day getting it squared away for our domain.
* **Where It Clearly Wins:** For standardized external communications, it's excellent. Our marketing and support teams have a "Formal" template doc. It enforces consistency in tone and catches genuinely unprofessional phrasing across a large, distributed team, which is a compliance win for us.
* **Where It Breaks / Limitation:** It falls flat on highly technical or niche content. For the API documentation the OP mentioned, our engineers found its suggestions on jargon and sentence structure actively harmful, creating confusion. We had to create a separate "Technical" document type with all Grammarly features disabled except for basic spelling. It's not a tool for that layer.

My pick is that Grammarly Business is a strong recommend if your primary use case is polishing *external, non-technical communication* at scale across a non-homogeneous writing staff. If your main pain point is internal comms or developer docs, I'd tell you to look elsewhere, like a simpler style guide enforced during code review. For a clean call, tell us the ratio of internal to external documents your team produces and whether your technical writers are already using a dedicated docs-as-code pipeline.

Exactly this. I run into the same thing with infrastructure documentation - the tone for a quick post-mortem blameless write-up (informal, just-the-facts) versus a formal RCA for leadership or a vendor needs totally different language.

I've started applying the same per-document logic to our internal wiki. The "Informal" setting is perfect for runbooks where the prose needs to be direct and action-oriented for the on-call engineer, while the "Formal" setting gets used for architecture decision records that might get shared externally.

It's a small workflow tweak, but it makes the tool feel less like a nag and more like a tailored assistant.

The point about productivity lag from constant toggling hits home. We had a similar issue with our API documentation - engineers kept disabling it for internal comments in the OpenAPI specs because the formal suggestions made things read like legal contracts.

Your note on SSO config is useful. We went through that with Google Workspace, but the bigger headache was getting the desktop app approved by our security team for install. Took a week of back-and-forth about network permissions.

Have you found the per-document setting sticks when sharing docs? We've had a few cases where a Google Doc set to informal resets when someone new opens it.

The per-document setting resetting on share is classic. I've seen it happen, but it's inconsistent. Seems to hold in Google Docs if the person opening it is already logged into their Grammarly account, but it's a coin toss with shared links to external parties.

Your security team tango is familiar, but honestly, we just told engineers to use the browser extension and skip the desktop app entirely. Less functionality, but it bypasses the approval circus. Not ideal, but neither is a week-long delay for a grammar checker.

That's a solid use case, and it mirrors our experience with incident documentation. We formalized it a bit by adding metadata tags to our template headers in the wiki. For example, a template for a post-mortem starts with a comment like ``, while an official ADR template has ``. It's a simple prompt for the writer and prevents that initial friction.

One caveat we've noticed is that the "Informal" setting can be too permissive for runbooks. It sometimes misses ambiguous phrasing that's critical for procedural clarity. We ended up creating a custom style guide snippet for runbooks that we paste in, which seems to guide the suggestions better than the broad informal setting alone.

That's a smart application, especially for runbooks where clarity and immediate action are critical. I've seen teams where the informal setting works well for internal comms, but they sometimes pair it with a short list of forbidden ambiguous terms for procedural steps, like "check" or "verify," to maintain precision.

Does your team find the tool's definition of "informal" aligns with your engineering culture, or have you had to adjust your writing style to fit its suggestions?

That per-document flexibility is the only way it's usable for me too. But I apply the same logic to my cloud cost reports, and let me tell you, the 'Formal' setting is a lifesaver for leadership decks.

Nothing gets a VP's eyebrow raised faster than a casual "this huge bill is probably because someone forgot to turn off a dev cluster lol" in a quarterly review. Grammarly helps me translate "our freaking RDS instances are idling" into "opportunities for resource right-sizing." It's the same sad reality, just with a better tone slider.

My caveat: it's useless for the actual anomaly detection scripts. The 'Informal' setting still tries to correct my JSON.

Oh, that's the real use case. I translate "what the hell happened last Thursday" into "anomalous peak during off-hours" for the finance deck every month.

Pro tip: I built a tiny script that preps my cost commentary before it even hits Grammarly. It swaps out developer-speak for biz-speak using a simple dictionary. "Cost explosion" -> "unexpected variance," "idle garbage" -> "identified optimization targets." It's just a find/replace, but it gives the tone slider a head start. Saves me from rolling my eyes while I write.

And yeah, it's completely blind to code. I keep a separate plugin-free editor open just for my Cost Explorer queries and scripts. It still tries to correct my Terraform.

Your question about aligning with "informal" is spot on. We found Grammarly's informal setting was too broad for our SRE team's culture, which values direct, unambiguous language, not casualness. It would often suggest conversational phrasings that introduced ambiguity into procedural steps.

We didn't adjust our style to fit the tool. Instead, we treated the informal setting as a baseline filter for egregious formality, then layered our own internal clarity rules on top. For example, in runbooks, we mandate specific action verbs: "restart the service" is required, while "check the service status" is forbidden in favor of "confirm the service health endpoint returns HTTP 200."

So the tool's definition is a starting point, but it's insufficient for operational precision. You still need a team-specific style guide to govern the actual technical communication.

You've identified a crucial limitation. The tool's definition of "informal" conflates conversational tone with operational clarity, which are often orthogonal concerns in SRE documentation.

Our team reached a similar conclusion and formalized it by integrating a custom dictionary into our docs-as-code pipeline. Our runbook Markdown files are processed by a linter that enforces our verb lexicon before any human or AI grammar check runs. For example, it flags generic verbs like "check" or "verify" and suggests replacements from our approved list, such as "execute," "validate," or "confirm."

This essentially makes the style guide machine-checkable, relegating Grammarly's informal setting to catch only basic grammatical issues. It turns the tool into a secondary linting pass focused on sentence structure, while the primary pass governs semantic precision.

You've hit on the important distinction. In our infrastructure team, the "informal" setting doesn't align with our culture of precise, declarative communication. We value brevity and unambiguity, not casualness. The tool often suggests softening or conversational phrasing that we actively avoid in operational context.

We adjusted our process, not our writing style, by treating Grammarly as a late-stage polish tool. We draft technical documents and runbooks with our required verb lexicon first, using a separate linter for enforcement. Only then do we run it through the grammar check with the informal setting, which then catches basic grammatical errors without interfering with our mandated command structure.

It's a bit of a workflow overhead, but it prevents the tool from "helping" us into vagueness. The core issue is that the product's formality axis is designed for general business communication, not for technical operational prose where tone and clarity are separate dimensions.

>getting the desktop app approved by our security team for install
That sounds familiar. We just went through this with our new SOC2 controls. The security team blocked the desktop app install entirely, citing potential data exfiltration. They even questioned the browser extension.

We had to provide a data flow diagram showing it only processes text in the active tab. Still took three meetings.

For your sharing question, we've seen the same reset issue. It seems to happen if the recipient's personal Grammarly account has a different default formality setting than the document. Have you tried setting the formality at the workspace level in the admin console?

That "half a day for SSO" is wildly optimistic for any regulated company. We tried rolling it out for a finance client and it took six weeks of back and forth with legal and compliance. They demanded a full audit trail of every API call before they'd even look at the SSO config.

The desktop app install hassle is real, but the Google Workspace integration is the real minefield. Once it's in there, it's processing everything in Drive by default. That's a much bigger surface area than a browser extension.

And the TCO is never just the license. It's the meetings.

That per-document granularity is a great find, and it mirrors something we do with our K8s manifests and documentation. I treat my docs folder like your project doc, where a single `docs/` directory holds everything from internal team RFCs (informal) to public-facing helm chart READMEs (formal).

Your point about pairing it with different "Goals" is key. For API documentation, I often set it to formal but with the "Audience" goal set to "Knowledgeable." This keeps the tone professional for external users but allows for necessary technical jargon without flagging every acronym.

One caveat we've run into: if you're using a docs-as-code workflow where everything is in markdown files in git, the formality setting doesn't always persist across branches or when a colleague opens a pull request. It's a document-level setting in Grammarly's cloud, not a file property. So our workaround is to add a small comment at the top of the markdown file, like ``, as a reminder for the team. Not perfect, but it helps keep the intent clear.