PolyGres

PolyWire

Put an intelligent control point in front of Postgres.#

Different protocols. Same policies. Same Postgres. One control point for every Postgres workload.

What is PolyWire?#

See how PolyWire works, stage by stage → — the detailed eight-stage pipeline behind this diagram.

Four ways teams put PolyWire to work#

Explore all PolyWire capabilities →

See it happen#

Pick a protocol — same demo, different client, same PostgreSQL on the other end.

$ sql app/password@//localhost:11521/postgres

SQLcl: Release 23.4 Production

SQL> SELECT * FROM orders;

ORDER_ID  CUSTOMER_ID  AMOUNT
--------  -----------  -------
    1001           42   129.99
    1002           57    89.50

2 rows selected.

SQL>

$ mysql -h 127.0.0.1 -P 13306 -u root -p

mysql> SELECT * FROM orders;

+----------+-------------+--------+
| order_id | customer_id | amount |
+----------+-------------+--------+
|     1001 |          42 | 129.99 |
|     1002 |          57 |  89.50 |
+----------+-------------+--------+
2 rows in set

mysql>

$ mongosh mongodb://localhost:27017

test> db.orders.find()

[
  { _id: 1001, customer_id: 42, amount: 129.99 },
  { _id: 1002, customer_id: 57, amount: 89.50 }
]

test>

$ curl -s localhost:9200/orders/_search

{
  "hits": {
    "total": { "value": 2 },
    "hits": [
      { "_source": { "order_id": 1001, "amount": 129.99 } },
      { "_source": { "order_id": 1002, "amount": 89.50 } }
    ]
  }
}

Real client. Real wire protocol. PostgreSQL database. No client rewrite. Table/document contents above are illustrative — the protocol and path are exactly real. (SQLcl, JDBC, and psql are what's most thoroughly verified today; see PolyWire capabilities for exact client-by-client coverage.)

Try PolyWire in 60 seconds#

What do you use? Point it at a Postgres you already have:

Stop one workload from taking down Postgres.#

QoS for Postgres, at the gateway. Prioritize, throttle, bound concurrency, and shed load — before Postgres saturates, not after it falls over. A real token-bucket admission controller, per workload class (query/write/ddl/txn). See Security for the full scope.

Different protocols. Same security policy.#

Oracle application? Same policy. MySQL application? Same policy. MCP agent? Same policy. Security follows the request, not the protocol.

SQL Firewall · ACL · Authentication · RLS · TLS · Secrets · Audit

Full, honestly-scoped security detail →

Explore PolyWire in depth — detailed architecture, comparison →

Built for enterprise Postgres#

Without PolyWire vs. with it#

Without PolyWire

• Different database infrastructure per protocol
• A separate connection proxy
• Different security controls per system
• Different observability per system
• Separate migration tooling
• A separate, unguarded AI access path

With PolyWire

One gateway → Postgres.

• Fewer systems to operate — one gateway instead of five databases' own tooling.
• One place to govern workloads — the same firewall, QoS, and audit path for every protocol.
• Standardize on Postgres — without rewriting every application first.

Why PolyWire?#

Capability	Direct to Postgres	Traditional proxy	PolyWire
Postgres wire protocol	✓	✓	✓
Foreign DB protocols (Oracle, MySQL, SQL Server, MongoDB…)	—	—	✓
Live dialect / semantic translation	—	—	✓, every call
SQL firewall	DB-side only	Some	✓
Workload QoS / admission control	DB-side only	Limited	✓
Intelligent routing	App/DB-side	Some	✓
Sharding	App/DB-side	Some	✓
Distributed caching	Separate system	—	✓
AI / MCP access, same governed path	Separate path	—	✓
Unified observability	Multiple layers	Proxy layer only	✓

Comparison methodology →

Compatibility, honestly scoped#

Every row below is verified against that protocol's real client library, not a synthetic harness — this table states only what's actually confirmed today; see full capabilities and ERRORS.md for the complete per-protocol detail, including known limitations.

"—" means not yet implemented for that protocol, stated plainly rather than omitted — see Security for exactly which protocols propagate a real per-caller identity today.

Built for production#

• HA & FailoverMulti-AZ PolyWire deployment, planned drain/switchover and automatic unplanned failover, both tested across every wire protocol. See Multi-AZ deployment and Planned and unplanned outages.
• SecuritySQL firewall, connection ACL, authentication, TLS, row-level security identity propagation, Vault/CyberArk secrets, admin SSO. See Security for the exact, honestly-scoped detail.
• Workload protectionQoS admission control, connection pooling, and load shedding before a backend saturates — see "Stop one workload from taking down Postgres" above.
• ObservabilityPrometheus /metrics and OTLP export, reaching Grafana, Datadog, New Relic, CloudWatch, Azure Monitor, and GCP Cloud Monitoring. See Observability.
• DeploymentDocker, Kubernetes, AWS, Azure, GCP, OCI, or on-prem — your infrastructure, your network, your Postgres.
• SupportCommunity support on Developer; enterprise support on Enterprise — see Pricing below.

Schedule a PolyWire Architecture Review →

Your infrastructure. Your Postgres.#

Docker · Kubernetes · AWS · Azure · GCP · OCI · On-prem

Run PolyWire next to the applications and databases you already operate — no managed control plane required.

Pricing

Same PolyWire, same protocols, same capabilities — Developer and Enterprise differ on scale and commercial rights, not features. Nothing that makes PolyWire what it is — SQL translation, the firewall, sharding, QoS, caching, HA/failover — is held back for a paid tier: an evaluation on Developer proves the exact architecture you'd run in production.

Developer's connection/instance/backend limits are real, locally-enforced caps — not a time-limited trial and not a phone-home metering service. They're enough to run applications, demos, benchmarks, and a genuine three-instance HA/failover test; a meaningful production deployment will reach them quickly by design.

Ready to put PolyWire in front of Postgres?

Try it free — Developer Edition, all features, all ten protocols. Taking it to production? Bring your architecture and we'll help map the deployment.

Also from PolyGres

PolyAdvisor — know before you migrate

PolyAdvisor plans the move to Postgres. PolyWire runs and governs workloads on Postgres. Assess → size → plan → move — Oracle, MySQL, MariaDB, SQL Server → Postgres, with a rules-based, reproducible difficulty score (not LLM-generated).

Explore PolyAdvisor — assessment, sizing, and PL/SQL review with an LLM's help →

Common questions

• Does my application need to change to use PolyWire?No — your existing driver connects exactly as it always has, unaware PolyWire is on the other end. Learn more →
• Is PolyWire's sharding real, or just SQL text matching?Real — it decodes each protocol's own native bound values and merges cross-shard results centrally. Learn more →
• Does PolyWire support row-level security?Yes, for Postgres, SQL Server, Oracle, and MySQL — a real per-caller identity feeds your own Postgres RLS policies. Learn more →
• What happens if the backend Postgres needs planned maintenance?A drain API redirects traffic and waits for a real zero-replication-lag cutover before confirming. Learn more →
• Can PolyWire connect to Supabase, RDS, Cloud SQL, Azure, or OCI?Yes — each has a worked example and its real provider-specific gotchas. Learn more →
• Does PolyWire cache query results?Yes — PolyCache serves repeat reads without a Postgres round trip, with automatic table-level invalidation. Learn more →
• What security features does PolyWire actually have wired in?SQL firewall, connection ACL, QoS, authentication, TLS, secrets management, and admin auth — each scoped honestly. Learn more →
• Is PolyWire free to use?Yes — Developer is free forever with every protocol and feature enabled, capped on scale. See Pricing above.
• Is PolyAdvisor's migration score generated by an LLM?No — it's rules-based and reproducible: the same database gives the same score every time.

Contact

Considering PolyWire for production? Bring your architecture — we'll help map where PolyWire fits. Pick "Architecture Review" below.

Report an issue or ask a question — for either PolyWire or PolyAdvisor. Include what you were trying to do and, for a bug, what you expected vs. what happened. Goes straight to the team, no email address to copy or scrape.