1# Durable Objects Gotchas
2 
3## Common Errors
4 
5### "Hibernation Cleared My In-Memory State"
6 
7**Problem:** Variables lost after hibernation  
8**Cause:** DO auto-hibernates when idle; in-memory state not persisted  
9**Solution:** Use `ctx.storage` for critical data, `ws.serializeAttachment()` for per-connection metadata
10 
11```typescript
12// ❌ Wrong - lost on hibernation
13private userCount = 0;
14async webSocketMessage(ws: WebSocket, msg: string) {
15  this.userCount++;  // Lost!
16}
17 
18// ✅ Right - persisted
19async webSocketMessage(ws: WebSocket, msg: string) {
20  const count = this.ctx.storage.kv.get("userCount") || 0;
21  this.ctx.storage.kv.put("userCount", count + 1);
22}
23```
24 
25### "setTimeout Didn't Fire After Restart"
26 
27**Problem:** Scheduled work lost on eviction  
28**Cause:** `setTimeout` in-memory only; eviction clears timers  
29**Solution:** Use `ctx.storage.setAlarm()` for reliable scheduling
30 
31```typescript
32// ❌ Wrong - lost on eviction
33setTimeout(() => this.cleanup(), 3600000);
34 
35// ✅ Right - survives eviction
36await this.ctx.storage.setAlarm(Date.now() + 3600000);
37async alarm() { await this.cleanup(); }
38```
39 
40### "Constructor Runs on Every Wake"
41 
42**Problem:** Expensive init logic slows all requests  
43**Cause:** Constructor runs on every wake (first request after eviction OR after hibernation)  
44**Solution:** Lazy initialization or cache in storage
45 
46**Critical understanding:** Constructor runs in two scenarios:
471. **Cold start** - DO evicted from memory, first request creates new instance
482. **Wake from hibernation** - DO with WebSockets hibernated, message/alarm wakes it
49 
50```typescript
51// ❌ Wrong - expensive on every wake
52constructor(ctx: DurableObjectState, env: Env) {
53  super(ctx, env);
54  this.heavyData = this.loadExpensiveData();  // Slow!
55}
56 
57// ✅ Right - lazy load
58private heavyData?: HeavyData;
59private getHeavyData() {
60  if (!this.heavyData) this.heavyData = this.loadExpensiveData();
61  return this.heavyData;
62}
63```
64 
65### "Durable Object Overloaded (503 errors)"
66 
67**Problem:** 503 errors under load  
68**Cause:** Single DO exceeding ~1K req/s throughput limit  
69**Solution:** Shard across multiple DOs (see [Patterns: Sharding](./patterns.md))
70 
71### "Storage Quota Exceeded (Write failures)"
72 
73**Problem:** Write operations failing  
74**Cause:** DO storage exceeding 10GB limit or account quota  
75**Solution:** Cleanup with alarms, use `deleteAll()` for old data, upgrade plan
76 
77### "CPU Time Exceeded (Terminated)"
78 
79**Problem:** Request terminated mid-execution  
80**Cause:** Processing exceeding 30s CPU time default limit  
81**Solution:** Increase `limits.cpu_ms` in wrangler.jsonc (max 300s) or chunk work
82 
83### "WebSockets Disconnect on Eviction"
84 
85**Problem:** Connections drop unexpectedly  
86**Cause:** DO evicted from memory without hibernation API  
87**Solution:** Use WebSocket hibernation handlers + client reconnection logic
88 
89### "Migration Failed (Deploy error)"
90 
91**Cause:** Non-unique tags, non-sequential tags, or invalid class names in migration  
92**Solution:** Check tag uniqueness/sequential ordering and verify class names are correct
93 
94### "RPC Method Not Found"
95 
96**Cause:** compatibility_date < 2024-04-03 preventing RPC usage  
97**Solution:** Update compatibility_date to >= 2024-04-03 or use fetch() instead of RPC
98 
99### "Only One Alarm Allowed"
100 
101**Cause:** Need multiple scheduled tasks but only one alarm supported per DO  
102**Solution:** Use event queue pattern to schedule multiple tasks with single alarm
103 
104### "Race Condition Despite Single-Threading"
105 
106**Problem:** Concurrent requests see inconsistent state  
107**Cause:** Async operations allow request interleaving (await = yield point)  
108**Solution:** Use `blockConcurrencyWhile()` for critical sections or atomic storage ops
109 
110```typescript
111// ❌ Wrong - race condition
112async incrementCounter() {
113  const count = await this.ctx.storage.get("count") || 0;
114  // ⚠️ Another request could execute here during await
115  await this.ctx.storage.put("count", count + 1);
116}
117 
118// ✅ Right - atomic operation
119async incrementCounter() {
120  return this.ctx.storage.sql.exec(
121    "INSERT INTO counters (id, value) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET value = value + 1 RETURNING value"
122  ).one().value;
123}
124 
125// ✅ Right - explicit locking
126async criticalOperation() {
127  await this.ctx.blockConcurrencyWhile(async () => {
128    const count = await this.ctx.storage.get("count") || 0;
129    await this.ctx.storage.put("count", count + 1);
130  });
131}
132```
133 
134### "Migration Rollback Not Supported"
135 
136**Cause:** Attempting to rollback a migration after deployment  
137**Solution:** Test with `--dry-run` before deploying; migrations cannot be rolled back
138 
139### "deleted_classes Destroys Data"
140 
141**Problem:** Migration deleted all data  
142**Cause:** `deleted_classes` migration immediately destroys all DO instances and data  
143**Solution:** Test with `--dry-run`; use `transferred_classes` to preserve data during moves
144 
145### "Cold Starts Are Slow"
146 
147**Problem:** First request after eviction takes longer  
148**Cause:** DO constructor + initial storage access on cold start  
149**Solution:** Expected behavior; optimize constructor, use connection pooling in clients, consider warming strategy for critical DOs
150 
151```typescript
152// Warming strategy (periodically ping critical DOs)
153export default {
154  async scheduled(event: ScheduledEvent, env: Env) {
155    const criticalIds = ["auth", "sessions", "locks"];
156    await Promise.all(criticalIds.map(name => {
157      const id = env.MY_DO.idFromName(name);
158      const stub = env.MY_DO.get(id);
159      return stub.ping();  // Keep warm
160    }));
161  }
162};
163```
164 
165## Limits
166 
167| Limit | Free | Paid | Notes |
168|-------|------|------|-------|
169| SQLite storage per DO | 10 GB | 10 GB | Per Durable Object instance |
170| SQLite total storage | 5 GB | Unlimited | Account-wide quota |
171| Key+value size | 2 MB | 2 MB | Single KV pair (SQLite/async) |
172| CPU time default | 30s | 30s | Per request; configurable |
173| CPU time max | 300s | 300s | Set via `limits.cpu_ms` |
174| DO classes | 100 | 500 | Distinct DO class definitions |
175| SQL columns | 100 | 100 | Per table |
176| SQL statement size | 100 KB | 100 KB | Max SQL query size |
177| WebSocket message size | 32 MiB | 32 MiB | Per message |
178| Request throughput | ~1K req/s | ~1K req/s | Per DO (soft limit - shard for more) |
179| Alarms per DO | 1 | 1 | Use queue pattern for multiple events |
180| Total DOs | Unlimited | Unlimited | Create as many instances as needed |
181| WebSockets | Unlimited | Unlimited | Within 128MB memory limit per DO |
182| Memory per DO | 128 MB | 128 MB | In-memory state + WebSocket buffers |
183 
184## Hibernation Caveats
185 
1861. **Memory cleared** - All in-memory variables lost; reconstruct from storage or `deserializeAttachment()`
1872. **Constructor reruns** - Runs on wake; avoid expensive operations, use lazy initialization
1883. **No guarantees** - DO may evict instead of hibernate; design for both
1894. **Attachment limit** - `serializeAttachment()` data must be JSON-serializable, keep small
1905. **Alarm wakes DO** - Alarm prevents hibernation until handler completes
1916. **WebSocket state not automatic** - Must explicitly persist with `serializeAttachment()` or storage
192 
193## See Also
194 
195- **[Patterns](./patterns.md)** - Workarounds for common limitations
196- **[API](./api.md)** - Storage limits and quotas
197- **[Configuration](./configuration.md)** - Setting CPU limits
198