Polymarket is reimbursing approximately $3.9 million after a third-party software incident, a case that should be required reading for any founder who embeds outside code on a customer-facing platform. About $2.7 million was stolen directly, with the remainder arising from interruption and manipulated positions. The incident began on October 29, trading was suspended, and the offending software was removed. The details matter because they show how an attack can succeed without stealing passwords or private keys at all.
What happened, on the reported facts
According to the reported account, malicious JavaScript was distributed via a script on Polymarket's international platform. The script came through compromised DebugBear DNS and registrar infrastructure. DebugBear's preliminary account states that DNS records were compromised through its registrar, with no confirmed intrusion into its development systems, and that the compromise may have targeted one customer.
Attackers then exploited logged-in traders' active sessions to sell positions and redirect assets, without stealing keys. That last point is crucial and often misunderstood. In many security incidents, the attacker needs a credential. Here, the attacker did not need to steal a key because the victim's own browser session — already authenticated — did the work. The malicious script ran inside a trusted page, in the context of a logged-in user, and used that trust to act.
Trading was suspended while the issue was addressed and the software removed. The cost of an incident is not only what is stolen, but also what is disrupted or unwound while the platform is down.
Why third-party scripts are privileged code
Founders often treat third-party scripts — analytics, performance monitoring, chat widgets, A/B testing tools, payment helpers, and similar embeds — as conveniences. Technically, they are far more than that. A script loaded on your page runs with the privileges of your page. It can read page content, observe user actions, modify what the user sees, and, in many setups, trigger actions in the user's session.
That is why the phrase "third-party scripts are privileged code" is not hyperbole. Adding a script is close to giving another company the ability to act as your site, for every visitor who loads that page. If that vendor is compromised — through its own systems, its DNS, its registrar, or its distribution pipeline — your users inherit the compromise.
The case adds a second lesson: vendor DNS and registrar security is your security. DebugBear's preliminary finding points to DNS records compromised through a registrar, not necessarily its development systems — so founders must ask who controls a vendor's domain and how DNS changes are approved and detected.
What founders should actually do
This analysis is not a checklist for a security audit, but it points to concrete practices founders should treat as product requirements, not afterthoughts.
First, inventory every third-party script on every customer-facing page, especially pages where users are logged in or transact. If you cannot list them, you cannot govern them. Remove scripts that are no longer used; stale embeds are a common and avoidable risk.
Second, apply least privilege. Ask whether a script needs to run on authenticated or transactional pages at all. Analytics or performance tools that are useful on marketing pages may be unnecessary — and unnecessarily risky — on trading, checkout, or account pages. Where a script is needed, use integrity checks and loading controls where technically appropriate, and limit what it can access.
Third, diligence vendors beyond their product. Ask how they protect their DNS and registrar accounts, how they distribute code updates, how they detect compromise, and how quickly they can notify customers. A vendor's security page that only discusses its application servers is incomplete if its distribution pipeline is the real risk.
Fourth, plan for session abuse. Assume that an attacker who can run code in a logged-in session will try to act as the user. That means sensitive actions — selling positions, withdrawing funds, changing payout destinations, altering account settings — should require additional confirmation, step-up authentication, or anomaly checks, not merely a valid session cookie.
Fifth, prepare incident response in advance: who can suspend a feature, who communicates to users, and how losses will be assessed. Those decisions are much harder under pressure.
What investors should diligence
For investors, this is a diligence prompt: what third-party code runs on logged-in pages, who are your vendors' vendors, and how do you monitor for unexpected script changes? A company answering clearly is less likely to suffer an incident that destroys trust, triggers reimbursement costs, and forces a shutdown. In financial and trading platforms, trust is the product.
The bottom line
The Polymarket incident did not require breaking cryptography or stealing keys. It required compromising a trusted distribution path and abusing trusted sessions. That is why it is so instructive. Founders who treat every third-party script as privileged code — and who hold vendors' DNS, registrar, and distribution security to the same standard as their own — will build platforms that are harder to turn against their own users.
Angeled.com connects founders with investors.
Read Next
What a Reported $15B Raise at a $1.25T Valuation Would Mean for OpenAI — and Everyone Else
AlphaGenome 2 and the New Tooling Layer for Biotech Founders
Big Law Is Now Paying Lawyers to Learn AI — and That Changes Legal Tech
Biotech's $348 Million Week: Brain Drugs, Radiopharma and Gene Therapy
Databricks' Always-On Genie and the End of the Chatbot Era
Gemini Decision 1: Google's AI That Answers Instead of Chatting



