Skip to main content

· 7 min read
Arkin Eliezer Julijanto

Meta Description: Backblaze quietly stopped backing up OneDrive and Dropbox folders without notifying users. Here's what this means for your backup strategy, why sync ≠ backup, and how to actually protect your data in 2026.

The Backup Provider That Stopped Backing Up​

Backblaze built its reputation on a simple promise: unlimited backup, no file restrictions, set-it-and-forget-it. For a decade, that promise held. People paid their subscription, installed the client, and slept easy knowing their files were safe in the cloud.

Then they quietly stopped backing up OneDrive, Dropbox, Google Drive, and other cloud-synced folders — and didn't tell anyone.

No email. No alert. No dashboard warning. Just a bullet point buried in release notes under "Improvements":

The Backup Client now excludes popular cloud storage providers from backup, including both mount points and cache directories. This prevents performance issues, excessive data usage, and unintended uploads from services like OneDrive, Google Drive, Dropbox, Box, iDrive, and others.

This wasn't listed in their official exclusions page either. Users discovered it the hard way — by noticing their OneDrive or Dropbox folders were simply missing from their backup.

One user, R.A. Reese, found 383GB of his OneDrive data was no longer being backed up. He'd been a Backblaze customer for ten years. He'd previously used their drive-restore service successfully. And he only found out because someone else posted about it on Reddit.

The .git Problem​

This isn't even the first time. Backblaze also stopped backing up .git folders at some point — again, without clear disclosure. Reese discovered this when he needed to restore a git repository's history after a force-push mistake, only to find Backblaze had silently excluded it.

The pattern is disturbing: a backup provider making unilateral decisions about what counts as "worth backing up" and not clearly communicating those decisions to the people paying for the service.

Why Sync Is Not Backup​

A reasonable objection: "Those files are already in OneDrive/Dropbox, so they're already backed up."

No. They're synced, not backed up. The distinction matters enormously.

  • Deleted file retention: OneDrive and Dropbox only retain deleted files for 30 days. Backblaze offers one year (or unlimited if you pay per GB).
  • Version history: Dropbox only retains version changes for 30 days on standard plans.
  • Account risk: If Microsoft or Dropbox suspends your account, your files are gone — and so is your "backup."
  • Ransomware protection: Sync services replicate changes (including malicious encryption) immediately. A proper backup maintains independent snapshots.

Your files are less secure in a cloud sync folder than sitting on your desktop with a proper backup solution. By excluding these folders, Backblaze effectively removed protection from some of the most critical data people own.

The Real Lesson: Trust Is the Product​

The technical issue here is solvable. You can reconfigure your backup. You can switch providers. You can set up a 3-2-1 strategy.

The deeper problem is about trust and transparency in SaaS.

Backblaze isn't selling storage. They're selling peace of mind. Their entire value proposition is: "You don't have to worry about your data." But by silently changing what they protect, they broke the fundamental contract. Users who checked their exclusions list in 2015 and trusted it would remain consistent were let down.

This pattern plays out across the SaaS ecosystem:

  • Features disappear in "updates" that are actually downgrades
  • Terms of service change without meaningful notification
  • Pricing shifts mid-contract with grandfathering that eventually expires
  • Data handling policies evolve in ways users never agreed to

The lesson for anyone relying on cloud services: your backup strategy is only as good as your monitoring of it. Set-it-and-forget-it is a myth. You need to periodically verify that what you think is being backed up is actually being backed up.

What This Means for Founders and Devs​

If you're running a startup or managing infrastructure, this story has three direct implications:

  1. Verify your backups. Don't just configure them — test restores regularly. Set calendar reminders to check what's actually being captured.
  2. Diversify your backup strategy. The 3-2-1 rule exists for a reason: 3 copies, 2 different media types, 1 off-site. No single provider should be your only safety net.
  3. Read your providers' release notes. It's tedious, but this is exactly how changes like this slip through. Or better yet, set up automated checks that alert you when backup sizes change significantly.

Building a Bulletproof Backup Strategy in 2026​

So what should you actually do? Here's a practical framework:

The 3-2-1-1-1 Strategy​

An evolution of the classic 3-2-1 rule:

  • 3 copies of your data
  • 2 different media types (local disk + cloud, for example)
  • 1 off-site copy (different geographic location)
  • 1 immutable copy (snapshot that can't be deleted or modified, even by you)
  • 1 air-gapped copy (completely disconnected from the network)

Practical Setup for Developers​

  • Local: Time Machine (macOS) or File History (Windows) to an external drive
  • Cloud backup: A provider like Backblaze, Arq, or restic to S3/B2 — but verify exclusions quarterly
  • Immutable: AWS S3 Glacier Deep Archive or similar with object lock
  • Repository data: Push to multiple git remotes (GitHub + GitLab, or GitHub + self-hosted)
  • Config files: Dotfiles repo, synced to a private git repository
  • Verification: Monthly restore test — pick a random file and actually recover it

Tools Worth Considering​

  • restic: Open-source, deduplicated, encrypted backups to multiple backends (S3, B2, SFTP, local)
  • Arq: Mac/Windows client that backs up to your own cloud storage (S3, B2, etc.)
  • Borg: Deduplicating backup tool with compression and encryption
  • Rclone: Syncs to 40+ cloud storage providers, acts as a Swiss Army knife for cloud data

The key insight: use tools where you control the configuration and the destination. If a provider can silently change what they back up, you've given them too much control.

FAQ​

Q: Can I re-enable OneDrive/Dropbox backup in Backblaze? A: As of version 9.2.2, Backblaze automatically excludes these folders. There's no toggle in the preferences to override this. Users have reported workarounds involving changing the backup selection manually, but this may be overridden by future updates. Check Backblaze's current documentation for the latest status.

Q: What's the difference between cloud sync and cloud backup? A: Cloud sync (OneDrive, Dropbox) mirrors your current file state across devices — if you delete a file locally, it's deleted from the cloud too. Cloud backup maintains independent snapshots with version history and longer retention, protecting against accidental deletion, ransomware, and device failure.

Q: How often should I test my backup restores? A: At minimum, quarterly. Ideally monthly. A backup you've never restored from is a backup you can't trust. Set a calendar reminder, pick a random file, and verify the restore works end-to-end.

Q: Is Backblaze still worth using? A: It depends on your needs. Backblaze remains affordable and easy to use, but this incident highlights the risk of trusting any single provider implicitly. If you use Backblaze, supplement it with additional backups you control, and verify what's actually being captured regularly.

About the Author​

Arkin is a startup founder and developer building Orbits Studio. He writes about tech, developer tools, and lessons from building in public. Find him at arkinjulijanto.github.io.

· 9 min read
Arkin Eliezer Julijanto

Meta Description: Claude Code Routines let you automate repetitive development tasks with scheduled jobs, API triggers, and GitHub webhooks. Here's how to build autonomous coding workflows that run 24/7.

Beyond Chat: When Your AI Agent Needs to Run on Autopilot​

Chat-based AI coding has transformed how developers work. But there's a limit to what you can do through conversational prompts alone. Sometimes you need work to happen while you're asleep — or while you're focused on something else entirely.

That's what Claude Code Routines are for: pre-configured Claude Code sessions that run automatically, triggered by schedules, API calls, or GitHub events. They execute on Anthropic-managed cloud infrastructure, so they keep working when your laptop is closed.

The release of Routines signals a broader shift in AI-assisted development: moving from interactive assistance to agentic automation. Instead of asking Claude to do something, you configure Claude to do it repeatedly, on its own schedule, without human intervention.

What Are Claude Code Routines?​

A Routine is a saved Claude Code configuration that includes:

  • A prompt defining the task
  • One or more GitHub repositories to work in
  • A set of MCP connectors for external services
  • One or more triggers that start the routine

When a trigger fires, Claude spins up a new cloud session, executes the prompt against the specified repositories, and creates a session record you can review later. It's like saving a perfect coding prompt and having Claude run it for you whenever you need.

Three Trigger Types​

Scheduled: Run on a recurring cadence — hourly, daily, weekdays, weekly, or custom cron intervals. Perfect for periodic maintenance tasks.

API: Trigger on demand with an HTTP POST to a dedicated endpoint. Use this to wire Claude Code into alerting systems, deploy pipelines, or internal tools.

GitHub: React to repository events like pull requests, pushes, or releases. Enables automated code reviews, PR triage, or synchronized library updates.

Key Capabilities​

  • Runs autonomously with no approval prompts
  • Can execute shell commands and use skills committed to repositories
  • Connects to external services via MCP (Slack, Linear, Google Drive, etc.)
  • Creates claude/-prefixed branches for its changes
  • Each run creates a session you can review or continue manually

What Can You Automate with Routines?​

The use cases are still emerging, but the documentation highlights several compelling patterns:

Backlog Maintenance​

A schedule trigger runs every weeknight, reading issues opened since the last run, applying labels based on the area of code, assigning owners, and posting a summary to Slack. Your team starts the day with a groomed queue instead of a messy backlog.

Alert Triage​

Your monitoring tool calls the routine's API endpoint when an error threshold is crossed. The routine pulls the stack trace, correlates it with recent commits, and opens a draft PR with a proposed fix. On-call reviews the PR instead of starting from a blank terminal.

Bespoke Code Review​

A GitHub trigger runs on pull_request.opened. The routine applies your team's own review checklist, leaves inline comments for security, performance, and style issues, and adds a summary comment so human reviewers can focus on design instead of mechanical checks.

Deploy Verification​

Your CD pipeline calls the routine's API endpoint after each production deploy. The routine runs smoke checks, scans error logs for regressions, and posts a go/no-go to your release channel before the deploy window closes.

Documentation Drift Detection​

A schedule trigger runs weekly, scanning merged PRs since the last run, flagging documentation that references changed APIs, and opening update PRs against the docs repository.

Cross-Language Library Ports​

A GitHub trigger runs on merged PRs in one SDK repository, ports the change to a parallel SDK in another language, and opens a matching PR — keeping multiple language implementations in sync without human re-implementation.

These patterns have something in common: they're unattended, repeatable, and tied to a clear outcome. That's the sweet spot for Routines.

How to Create a Routine​

From the Web Interface​

  1. Visit claude.ai/code/routines and click New routine
  2. Name the routine and write the prompt — this is the most important part. The routine runs autonomously, so the prompt must be self-contained and explicit about what to do and what success looks like
  3. Select one or more GitHub repositories. Claude clones them from the default branch and creates claude/-prefixed branches for changes
  4. Pick a cloud environment that controls network access, environment variables, and setup scripts
  5. Configure triggers — you can combine schedule, API, and GitHub triggers on a single routine
  6. Review connectors — remove any MCP connectors the routine doesn't need
  7. Click Create. The routine runs the next time a trigger matches

From the CLI​

Run /schedule in any session to create a scheduled routine conversationally. You can also pass a description directly: /schedule daily PR review at 9am.

The CLI creates scheduled routines only. To add API or GitHub triggers, edit the routine on the web. The CLI also supports managing existing routines with /schedule list, /schedule update, and /schedule run.

Key Configuration Details​

  • Prompts must be self-contained: The routine runs without you, so the prompt needs to explain everything — what to look for, how to decide, what to output
  • Scoping matters: What a routine can reach is determined by the repositories you select, environment variables, and connectors. Scope each to what the routine actually needs
  • Branch behavior: Claude creates claude/-prefixed branches by default. Enable "Allow unrestricted branch pushes" if the routine needs to push to other branches
  • Identity: Anything a routine does through your connected GitHub or connectors appears as you — commits carry your GitHub user, Slack messages use your linked account

Trigger Types in Depth​

Schedule Triggers​

Preset frequencies: hourly, daily, weekdays, weekly. Times are entered in your local timezone and converted automatically.

For custom intervals (every two hours, first of each month), pick the closest preset in the web form, then use /schedule update in the CLI to set a specific cron expression. The minimum interval is one hour.

Runs may start a few minutes after the scheduled time due to stagger, but the offset is consistent for each routine.

API Triggers​

Each routine gets a dedicated HTTP endpoint. POSTing with a bearer token starts a new session and returns a session URL you can open to watch the run in real time.

The request body accepts an optional text field for run-specific context (alert body, failing log, etc.). This is passed to the routine alongside its saved prompt as freeform text.

curl -X POST https://api.anthropic.com/v1/claude_code/routines/trig_XXXX/fire \
-H "Authorization: Bearer sk-ant-oat01-xxxxx" \
-H "anthropic-beta: experimental-cc-routine-2026-04-01" \
-H "anthropic-version: 2023-06-01" \
-H "Content-Type: application/json" \
-d '{"text": "Sentry alert SEN-4521 fired in prod. Stack trace attached."}'

Each routine has its own token, scoped to triggering that routine only. Tokens are shown once during generation — store them securely in your alerting tool's secret store.

Note: The API ships under an experimental beta header. Breaking changes will ship behind new dated headers, with the two most recent versions supported for migration time.

GitHub Triggers​

A GitHub trigger starts a new session automatically when a matching event occurs. Each matching event fires its own session.

You'll need to install the Claude GitHub App on the repository you want to subscribe to. The trigger setup prompts you to install it if needed.

Important: During research preview, GitHub webhook events are subject to per-routine and per-account hourly caps. Events beyond the limit are dropped until the window resets.

Security and Scoping Considerations​

Routines run autonomously with no approval prompts. This means you need to think carefully about:

  • Repository access: Only select repositories the routine actually needs
  • Environment variables: Provide only the secrets and keys required for the task
  • Network access: Configure the appropriate level of internet access
  • Connectors: Include only the MCP connectors the routine uses

Anything a routine does appears as you — commits carry your GitHub user, connector actions use your linked accounts. Treat routine prompts like production code: clear instructions, error handling, and verification steps.

The Bigger Picture: From Assistants to Agents​

Routines represent an evolution in AI-assisted development. They move us from:

  • Interactive → Autonomous: Claude does work while you're away
  • One-off → Repeatable: Configure once, run forever
  • Task-based → Workflow-based: Entire processes, not just individual actions

This is the direction the industry is heading. Tools like Plain (a Python framework built for agents) and the rise of MCP connectors all point toward a future where AI agents are first-class members of development teams — not just assistants in the IDE, but autonomous workers in the CI/CD pipeline.

The challenge shifts from "how do I get Claude to help me with this?" to "how do I design reliable, trustworthy autonomous workflows?" Prompts become code. Testing becomes crucial. Monitoring and observability matter.

Routines are early days — the feature is in research preview with limits that may change. But they're a clear signal of where AI-assisted development is going.

FAQ​

Q: Do Claude Code Routines require a paid plan? A: Yes, Routines are available on Pro, Max, Team, and Enterprise plans with Claude Code on the web enabled. They're not available on free plans.

Q: Can I share routines with my team? A: During research preview, routines belong to your individual claude.ai account. They're not shared with teammates. Each team member would need to create their own routine, or you'd need to coordinate using shared prompts and configurations.

Q: What happens if a routine fails? A: Each routine run creates a session you can review. If a routine fails or produces unexpected results, you can open the session URL to see what happened, review changes, and continue the conversation manually. You should also add error handling and verification steps to your routine prompts.

Q: Are there limits on how often routines can run? A: Yes, during research preview there are per-routine and per-account hourly limits. The specific limits depend on your plan and are visible at claude.ai/code/routines. Events beyond the limit are dropped until the window resets.

Q: Can routines run concurrently? A: Yes, each trigger event starts its own independent session. A single routine can have multiple sessions running simultaneously if multiple triggers fire in quick succession.

· 7 min read
Arkin Eliezer Julijanto

The open-source movement hit a wall today — and AI is the bulldozer. Cal.com, once the darling of open-source SaaS, just went closed source, citing AI-driven security threats. Google quietly handed a student's data to ICE without notice, breaking a decade-old promise. And the tools meant to protect us are the same ones being weaponized. This tech news roundup covers the stories that matter most to builders, founders, and anyone paying attention to where trust is eroding in tech.

· 6 min read
Arkin Eliezer Julijanto

Meta Description: Southeast Asia’s commerce is increasingly video- and social-led, yet many brands still underfund user-generated proof. Here is why that mismatch happens—and how to treat UGC as strategy, not decoration.

If you work on growth or brand in Southeast Asia (SEA), you have probably seen the same slide twice: a glossy hero TVC on one side, and a “community / UGC pilot” squashed into a footnote on the other. User-generated content (UGC) is not absent from the region—it is everywhere in chats, reviews, livestreams, and stitch-and-duet culture. What is underrated is how seriously organizations fund it, protect it, and measure it alongside performance media.

This post is about that gap: why UGC looks optional when the purchase journey is increasingly social, and what to do about it without pretending there is a single magic metric for every category.

· 9 min read
Arkin Eliezer Julijanto

Meta Description: A bot called "Nothing Ever Happens" systematically buys No on Polymarket prediction markets — and it's profitable. Here's why most predicted events don't happen, and what it teaches us about decision-making.

The Simplest Strategy That Actually Works​

Here's a trading strategy so simple it sounds like a joke: bet against everything. No analysis, no research, no domain expertise. Just systematically buy "No" on every non-sports prediction market you can find.

That's exactly what Nothing Ever Happens does. It's an open-source Python bot by Sterling Crispin that scans Polymarket — the world's largest prediction market — and buys No shares on standalone yes/no markets. No sports (those are efficient). No complex multi-outcome markets. Just binary bets on whether something will happen, and the bot always says it won't.

And it makes money.

Not "maybe kinda sorta" money. Consistent, systematic, boring profit. Because the uncomfortable truth about prediction markets — and human psychology in general — is that people dramatically overestimate the probability of interesting things happening.

Why "No" Is Undervalued​

The Base Rate Problem​

Most events that people create prediction markets about are, by definition, unusual. "Will Bitcoin hit $150K by June?" "Will there be a US-China military conflict before 2027?" "Will a category 5 hurricane hit Florida this season?"

These are exciting questions. That's why they get markets in the first place. But excitement and probability are inversely correlated. The more dramatic an event, the less likely it is to occur — and the more humans tend to overestimate its probability.

This is a well-documented cognitive bias called base rate neglect. When asked to judge the probability of an event, people focus on the specific, vivid details of the scenario rather than the statistical baseline. "Will there be a ceasefire by April?" feels more likely when you're reading news articles about peace talks than when you're looking at the historical base rate of ceasefire agreements actually being implemented.

Prediction markets are supposed to be the antidote to this — the "wisdom of crowds" aggregating information into a single number. But crowds are made of people, and people are biased toward interesting outcomes.

The Market Structure That Makes This Work​

The bot specifically avoids sports markets. That's not an accident. Sports betting markets are liquid, heavily traded, and extremely efficient. The odds on a Premier League match reflect genuine information — team form, injuries, weather, historical matchups. There's no structural edge in betting "this team won't win" across all matches.

Non-sports prediction markets are different. They're thinner, driven by narratives and news cycles, and populated by participants who are there because they care about the outcome — not because they're pricing it efficiently. A market about a political event attracts people with political convictions, not dispassionate probability assessors.

This creates a systematic upward bias in "Yes" prices. Events get priced higher than their true probability because the people trading them want them to happen, or because the narrative around them makes them feel likely.

How the Bot Works​

The architecture is straightforward:

  1. Scan — The bot continuously scans Polymarket for standalone yes/no markets (not multi-outcome, not sports)
  2. Filter — It looks for "No" shares trading below a configured price cap — cheap "No" contracts on events the market thinks are likely
  3. Buy — It purchases those "No" shares
  4. Wait — When the event doesn't happen (which is the base case for most events), the "No" shares resolve to $1 and the bot profits

The bot is built with async Python, runs on Heroku with a single web dyno, and includes a dashboard for monitoring positions. It has paper trading mode (default), live trading (requires explicit environment flags), and full state recovery for restarts.

The safety rails are real: BOT_MODE=live, LIVE_TRADING_ENABLED=true, and DRY_RUN=false must all be set, plus a private key and funder address. Without all of them, it defaults to paper trading. This is clearly a project by someone who doesn't want to accidentally lose real money.

The Deeper Lesson: Most Things Don't Happen​

This bot is profitable because of a fundamental truth about the world that most people — including smart, well-informed people — systematically underestimate:

Most things that could happen, don't.

  • Most proposed legislation doesn't pass
  • Most rumored acquisitions don't materialize
  • Most geopolitical crises de-escalate
  • Most "unprecedented" events have precedents that showed they were precedented
  • Most deadlines get extended
  • Most breakthrough announcements are incremental

This isn't pessimism. It's statistics. The prior probability for any specific event is almost always low, because the space of possible events is enormous and only a tiny fraction of them actually occur.

Prediction market participants — and humans in general — consistently fail to price this correctly. They see a market priced at 30% "Yes" and think "that seems reasonable, there's a real chance." But the base rate for most prediction market events resolving "Yes" is probably closer to 15-20%. That gap is the bot's profit margin.

What This Means for Decision-Making​

For Founders and Builders​

Every startup decision involves prediction. "Will this market be big enough?" "Will this competitor ship before us?" "Will this partnership close?" "Will this feature move the needle?"

The "Nothing Ever Happens" heuristic suggests you should:

  • Default to the boring outcome. Competitors won't ship that feature on time. The partnership will take 3x longer than expected. The market won't grow as fast as the reports say.
  • Treat exciting predictions with extra skepticism. If someone's excited about an outcome, they're probably overestimating its probability.
  • Build for the base case, not the best case. Your business model should work if the boring thing happens. The exciting thing is a bonus.

For Investors​

If prediction markets systematically overestimate the probability of interesting events, then:

  • Narrative-driven investments are overpriced. If everyone's talking about it, the upside is already baked in.
  • The best trades are boring. Buying "No" on exciting events is like buying index funds instead of meme stocks.
  • Contrarian isn't always right, but consensus is often wrong in predictable ways. The crowd isn't wrong about everything — it's specifically wrong about the probability of change.

For Anyone Making Decisions Under Uncertainty​

The next time you're estimating whether something will happen, try this:

  1. Find the base rate. How often does this type of thing actually happen? Not this specific instance — the category.
  2. Adjust slightly for specifics. If the base rate is 10%, the specifics might move it to 12% or 8%. They rarely move it to 40%.
  3. Check for emotional bias. Are you estimating high because you want it to happen, or because the evidence actually supports it?

The Risks (Because Nothing Is Free)​

This strategy isn't without danger:

  • Black swans are expensive. When something does happen that the market thought wouldn't, you lose. And since you're betting against interesting outcomes, the losses happen precisely when everyone is paying attention.
  • Market dynamics can shift. If this strategy becomes popular, "No" prices will correct upward and the edge disappears. The edge exists because most participants are on the other side.
  • Liquidity constraints. You can only bet "No" on markets that exist and have enough liquidity to fill your orders. The most overpriced "Yes" markets might be the ones you can't actually trade.
  • Resolution risk. Prediction markets depend on clear resolution criteria. Ambiguous outcomes can lead to disputes, and you're exposed to the platform's resolution mechanics.

The Takeaway​

"Nothing Ever Happens" is a brilliant project not because it's a sophisticated trading system — it's deliberately not. It's brilliant because it exploits a fundamental human bias with minimal complexity. The entire strategy fits in a sentence: bet against interesting things, because interesting things rarely happen.

In a world obsessed with predicting the future — from startup pitch decks to geopolitical analysis to your fantasy football league — the most powerful insight might be the simplest one. The future is mostly like the present. Things continue. Status quo wins. Nothing ever happens.

And if you want to make money off that realization, the code is open source.

FAQ​

Q: How much money has the Nothing Ever Happens bot made? A: The creator hasn't disclosed exact profits. The bot is open-source and provided "for entertainment only." The strategy's edge comes from systematically exploiting base rate neglect in non-sports prediction markets, but returns depend on market conditions, position sizing, and liquidity.

Q: Can I run this bot myself? A: Yes, the code is on GitHub. You'll need a Polymarket account with funded wallets, a Polygon RPC endpoint, and a Heroku account (or similar) to host it. The bot defaults to paper trading — live mode requires explicitly setting three environment flags plus your private key.

Q: Why does this strategy not work on sports markets? A: Sports betting markets are highly liquid and efficient. Thousands of professional bettors, bookmakers, and algorithms price sports events with extreme accuracy. Non-sports prediction markets are thinner and dominated by participants with emotional or narrative-driven biases, creating the mispricing this bot exploits.

Q: What is base rate neglect? A: Base rate neglect (or base rate fallacy) is a cognitive bias where people ignore the general probability of an event happening in favor of specific, vivid information. For example, hearing about peace talks makes a ceasefire "feel" likely, even though historically, most ceasefire negotiations fail.

Q: Is prediction market betting legal? A: Polymarket operates on the Polygon blockchain and is available in many jurisdictions, but regulatory status varies. In the US, prediction markets for events (not sports) exist in a gray area with some CFTC oversight. Check your local regulations before participating.


Inspired by Sterling Crispin's Nothing Ever Happens bot. Not financial advice. Really.

· 5 min read
Arkin Eliezer Julijanto

The AI coding tool ecosystem exploded this week — and it's not just Cursor and Copilot anymore. Claude Code is eating the developer tooling stack from the inside out, with an entire ecosystem of plugins, memory systems, and best-practice guides trending simultaneously. Meanwhile, Backblaze quietly nuked cloud folder backups for millions of users, and Google drew a line in the sand on SEO spam. Here's what matters in today's tech news roundup.

· 9 min read
Arkin Eliezer Julijanto

Meta Description: An attacker bought a 30-plugin WordPress portfolio on Flippa and injected backdoors into every one. Here's how it happened, why it matters, and what every developer should learn from it.

The Attack You Don't See Coming​

Imagine waking up to find that a plugin you've trusted for years — one with hundreds of thousands of installs — has been quietly owned for eight months. Not by a zero-day exploit. Not by a clever hack. But because someone literally bought the company that made it.

That's exactly what happened in April 2026. A buyer who goes by "Kris" purchased a portfolio of 30+ WordPress plugins from their original creators through Flippa, a marketplace for buying and selling online businesses. The very first code commit after the acquisition? A backdoor.

WordPress.org had to close all 31 plugins in a single day. Hundreds of thousands of websites were affected. And the most chilling part: the malware sat dormant for eight months before anyone noticed.

If you build software, maintain dependencies, or run any kind of web property, this story is a masterclass in why supply chain security is the threat most teams still aren't taking seriously.

How the Whole Thing Unfolded​

The Original Creators​

The plugins were built by an India-based team operating under "WP Online Support" starting around 2015. Minesh Shah, Anoop Ranawat, and Pratik Jain grew a portfolio of 30+ free WordPress plugins with premium upsells — things like countdown timers, galleries, sliders, and FAQ widgets. They later rebranded to "Essential Plugin."

By late 2024, revenue had dropped 35-45%. Running a WordPress plugin business is hard — maintaining free plugins, dealing with support, competing with page builders eating your lunch. So Minesh listed the whole business on Flippa.

The Acquisition​

A buyer identified only as "Kris" — with a background in SEO, crypto, and online gambling marketing — bought the entire portfolio for six figures. Flippa even published a case study about the sale in July 2025, celebrating it as a success story.

The new owner created a fresh WordPress.org account ("essentialplugin") and began updating the plugins. On paper, everything looked normal. Plugin updates, compatibility fixes, the usual changelog entries.

The First Commit Was the Backdoor​

On August 8, 2025, version 2.6.7 of Countdown Timer Ultimate was released. The changelog read: "Check compatibility with WordPress version 6.8.2." Clean, boring, the kind of update no one looks twice at.

What the update actually did was add 191 lines of code to class-anylc-admin.php, growing it from 473 to 664 lines. Three new capabilities were introduced:

  • A fetch_ver_info() method that called file_get_contents() on the attacker's server and passed the response to @unserialize() — a classic PHP deserialization vector
  • A version_info_clean() method that executed @$clean($this->version_cache, $this->changelog) where all three values came from the unserialized remote data — a textbook arbitrary function call
  • An unauthenticated REST API endpoint with permission_callback: __return_true — meaning anyone could hit it without logging in

The remote server controlled the function name, the arguments, everything. And it sat there for eight months, dormant, waiting.

The Weaponization​

On April 5-6, 2026, the sleeping backdoor woke up. The plugin's wpos-analytics module phoned home to analytics.essentialplugin.com, downloaded a file called wp-comments-posts.php (deliberately named to look like WordPress core's wp-comments-post.php), and used it to inject a massive block of PHP into wp-config.php.

The injected malware was sophisticated:

  • It fetched spam links, redirects, and fake pages from a command-and-control server
  • It only showed spam content to Googlebot — making it completely invisible to site owners browsing their own site
  • The C2 domain resolved through an Ethereum smart contract, querying public blockchain RPC endpoints — meaning traditional domain takedowns were useless because the attacker could update the smart contract to point to a new domain at any time

Using blockchain for C2 infrastructure is next-level. There's no registrar to subpoena, no hosting provider to send a takedown to. The domain resolution is decentralized by design.

The Forensic Discovery​

Mike Schroder from CaptainCore discovered the attack through backup forensics. By extracting wp-config.php from daily restic backups across eight different dates, he tracked the file size changes:

  • November 2025 through April 5, 2026: ~3,345 bytes (normal)
  • April 7, 2026: 9,540 bytes (injected)

The injection happened in a 6-hour 44-minute window on April 6, 2026. A normal update that no one would question triggered the payload that had been sleeping for eight months.

Here's the kicker: WordPress.org pushed a forced update (v2.6.9.1) that neutralized the phone-home mechanism in the plugin. But it did not clean wp-config.php. The SEO spam injection was still actively serving hidden content to Googlebot even after the "fix."

Why This Matters Beyond WordPress​

You might be thinking, "I don't use WordPress plugins, so I'm fine." You're not. This attack pattern applies to every software ecosystem:

1. Your Dependencies Are Your Attack Surface​

Every npm package, every pip library, every NuGet dependency, every WordPress plugin — you're trusting the maintainer. When that maintainer changes (sell, burn out, get compromised), your trust model breaks. The event-stream incident in npm, the ua-parser-js hijack, and now this — the pattern is the same.

2. Dormant Backdoors Are Nearly Undetectable​

The code sat there for eight months doing nothing. No suspicious network traffic. No anomalous file writes. No triggers for any security scanner. The malicious code was structured to look like a legitimate analytics module. How many dormant backdoors are sitting in your node_modules right now?

3. Acquisition Is the New Attack Vector​

Buying a legitimate business to weaponize its user base is a supply chain attack that doesn't require any technical exploitation. It's purely social and economic. If you maintain popular open-source software, think about what happens if someone buys your project — or your contributor's project, or the project you forked from.

4. Auto-Updates Are a Double-Edged Sword​

WordPress auto-updates pushed the compromised code to hundreds of thousands of sites automatically. The mechanism designed to keep users safe was weaponized against them. This is the paradox of auto-updates: they protect you from known vulnerabilities but increase your exposure to supply chain attacks.

Practical Steps to Protect Yourself​

For Developers and Founders​

  • Audit your dependency tree regularly. Not just direct dependencies — transitive ones too. Tools like npm audit, pip-audit, or Snyk can help, but they only catch known vulnerabilities, not intentional backdoors.
  • Pin your dependencies. Don't auto-update production dependencies. Review changelogs before upgrading. If a "compatibility fix" adds 191 lines of code, that's a red flag.
  • Monitor file integrity. Set up alerts for unexpected changes to critical files (wp-config.php, .env, config files, entry points).
  • Use lockfiles religiously. package-lock.json, poetry.lock, yarn.lock — these are your safety net against silent dependency mutations.

For WordPress Site Owners​

  • Remove plugins you're not actively using. Every installed plugin is a potential attack vector.
  • Check who maintains your plugins. If ownership recently changed, verify the new maintainer's credibility.
  • Monitor wp-config.php and core files. Use file integrity monitoring (Wordfence, Sucuri, or CaptainCore's backup forensics approach).
  • Don't blindly trust auto-updates. Especially for plugins from small or recently acquired teams.

For Open-Source Maintainers​

  • Add transfer policies to your project. Document what happens if you sell or hand off the project. Some projects now include clauses in their governance docs preventing sale without community review.
  • Sign your releases. GPG signatures on tags and releases make it harder for a new owner to quietly inject malicious code.
  • Make your code reviewable. If your changelogs are honest and your commits are readable, the community can catch anomalies faster.

The Bigger Picture​

The WordPress plugin ecosystem is uniquely vulnerable because of its size and update mechanics. There are over 60,000 plugins in the WordPress.org directory. Most are maintained by small teams or solo developers. Many generate modest revenue. The economics of selling a declining plugin business are real, and buyers with malicious intent can exploit that.

But the core lesson isn't about WordPress. It's about trust in software supply chains. When you install a dependency, you're trusting not just the current version of the code — you're trusting the maintainer's future decisions, their financial stability, and their integrity.

In 2026, supply chain attacks are no longer theoretical. They're a business model. Someone literally bought a company just to backdoor its customers. If that doesn't make you reconsider your dependency strategy, nothing will.

FAQ​

Q: How many websites were affected by this WordPress plugin backdoor? A: The 31 closed plugins had hundreds of thousands of combined active installations. The exact number of compromised sites is still being determined, as the backdoor only activated in April 2026 after lying dormant since August 2025.

Q: What should I do if I had any Essential Plugin plugins installed? A: Immediately check your wp-config.php for suspicious code blocks, scan your site with a security tool like Wordfence or Sucuri, and remove any Essential Plugin plugins. The WordPress.org forced update only neutralized the phone-home mechanism — it did not clean existing infections.

Q: Can this type of supply chain attack happen to npm or pip packages? A: Yes, and it already has. The event-stream incident (2018) and ua-parser-js hijack (2021) followed similar patterns. Any ecosystem with third-party dependencies is vulnerable to maintainer compromise or acquisition-based attacks.

Q: What is a blockchain-based command-and-control server? A: Instead of using a traditional domain name that can be seized by authorities, the attacker stored their C2 server address in an Ethereum smart contract. The malware queries the blockchain to get the current server address, making takedown nearly impossible without controlling the smart contract.

Q: How can I detect dormant backdoors in my dependencies? A: There's no perfect solution, but you can: pin and lock dependencies, review diffs before updating (especially after ownership changes), use static analysis tools, monitor for unexpected network calls, and implement file integrity monitoring on production systems.


Based on the original forensic investigation by Mike Schroder at CaptainCore.

· 17 min read
Arkin Eliezer Julijanto

Meta Description: McKinsey says agentic AI will power more than 60% of the total value AI generates in marketing and sales. Here's the data — adoption numbers, real case studies, org chart changes, and what the maturity gap means for teams still running pilots.

McKinsey's November 2025 analysis put a number on something most marketing leaders had already sensed: agentic AI will power more than 60% of the total increased value that AI is expected to generate across marketing and sales. Not a portion of the gains. The majority. And unlike the productivity claims that have surrounded every AI tool since 2022, this isn't about writing faster or scheduling posts. It's about agents that optimize prices, advance leads, run A/B tests, and manage customer interactions end-to-end — without waiting for a human to press go.

The data from 2026 tells a split story: near-universal adoption of AI tools, but a deep maturity gap in how teams are actually using them. Understanding that gap is the whole game right now.

· 9 min read
Arkin Eliezer Julijanto

Meta Description: Most engineering teams don't know their true ROI. Here's why measuring software economics matters — and why it's harder than it looks.**

The $60,000 Question​

Here's a scenario that plays out in engineering organizations every day: Your team spends three weeks building a feature that serves 2% of your users. With a typical all-in engineering cost of €100,000 per year, that's roughly €60,000 of investment for a minority of your user base.

Was it worth it?

If you're like most engineering leaders, you don't know. You have a gut feeling. You have some usage metrics. You have a vague sense that "the sales team said they needed this." But you don't have a number — or even a method for generating one.

This is the core thesis of the discussion around software team economics: Most engineering organizations are flying blind when it comes to understanding the financial impact of their work.

The Optimization Trap​

The seductive argument goes like this: If every feature decision were made with clear ROI calculations, organizations would make better decisions. A €60,000 feature for 2% of users is easy to evaluate against a €60,000 feature for 20% of users. Armed with this data, engineering leaders could reallocate resources to high-impact work and eliminate waste.

There's truth to this. In the zero-interest-rate era, companies hired aggressively, shipped aggressively, and worried about efficiency later. That era is over. Companies that can't connect engineering output to business outcomes are in trouble.

But there's a trap here.

What Gets Measured Gets Managed (And Sometimes Broken)​

The first problem is attribution. Software doesn't exist in a vacuum. Your company ships 10 features in a quarter, revenue goes up $1M, and you land a new enterprise contract that uses all of them. How much of that revenue belongs to Feature #7?

Every team will attribute the entire win to themselves. The alternative — revenue that disappears without explanation — is politically unacceptable. So you end up with sum-of-parts greater than the whole, and metrics that no one trusts.

The second problem is the measurement burden. If every feature needs a dollar value attached, who does the calculation? Product managers become analysts. Engineers spend time setting up measurement baselines for work that hasn't shipped yet. The meta-work of justifying work starts to rival the work itself.

The third problem is the most insidious: innovation doesn't have a clear ROI when you start.

The Innovation Paradox​

WhatsApp was built by 30 engineers serving 1 billion users. But WhatsApp in 2010 didn't have 1 billion users. It had a few thousand. At what point in that journey did the feature work of those 30 engineers become "worth it"?

If you measured strictly by short-term ROI at every step, you might have killed the project six months in. The features that matter now — end-to-end encryption, cross-platform sync, minimal data collection — were long-term bets that looked like waste when they were built.

This is the paradox: The most valuable engineering work often looks like waste until it becomes indispensable.

The Missing Layer: Baseline Before Optimization​

There's a sensible middle ground that gets lost in the "bean counters vs. pampered artists" framing.

The problem isn't measurement itself. The problem is measuring without baselines. Consider a DevOps engineer who automates a manual task that cost every developer 2 hours per week. That's 80 hours saved per week for a 40-person team. But what do those engineers do with the extra time?

If they use it to ship more features, the ROI is clear. If they take longer lunches, the ROI is zero. The difference isn't about the automation — it's about whether the freed-up capacity has a place to go.

As one commenter put it: "Profile before you optimize and the return on investment calculates itself." Most organizations skip the profiling step. They don't measure what happens now, so they can't measure what happens after.

The 3-5x Rule​

There's a rule of thumb that circulates in engineering leadership: A feature needs a 3-5x return on investment to be worth building. The math is simple: Building a feature costs €60,000. If it generates less than €180,000 of value, you're losing money.

But here's what this rule misses:

  1. Lifetime value vs. first-year value. A feature might cost €60,000 to build but generate €20,000 annually for five years. That's a 4x return, but if you measure strictly in year one, it looks like a failure.

  2. Capability building, not just features. Some work doesn't generate revenue directly but enables revenue-generating work. Infrastructure platforms, developer tooling, security hardening — these are investments in capability.

  3. Option value. A feature for 2% of users might unlock an adjacent market segment. That 2% might be a beachhead for a much larger opportunity.

The Role of AI in All This​

The original discussion that sparked this thread included a provocative claim: AI agents can replace much of what engineering teams do today, at lower cost, with different trade-offs.

The counter-arguments were equally strong: AI-generated code becomes unmanageable technical debt. Agents can't reason through unfamiliar systems at scale. You still need a human to fire and sue.

But the deeper question isn't "Will AI replace engineers?" It's: "How does AI change the economics of software production?"

If AI can ship a 95% clone of Slack in two weeks (as the original article claimed), what does that mean for teams spending years building products from scratch? The value of engineering has always been more than lines of code per hour. But as the cost of code drops, the value of everything else — product judgment, user empathy, strategic thinking — rises.

What Actually Matters​

Here's what the most productive engineering teams actually do:

They focus on problems they care about. One commenter put it best: "The only thing that matters is whether the people on the team care deeply about the product." Teams that don't care have a productivity ceiling no amount of process can fix.

They build in increments. Shipping 10 major features in a quarter makes attribution impossible. Shipping one feature every week makes it clear what landed and what didn't.

They understand the business. Engineers who know how their company makes money — not just "we sell software" but "we sell to HR directors at 500-person companies with specific compliance needs" — make better decisions.

They accept uncertainty. Not every feature will succeed. Not every infrastructure investment will pay off. The goal isn't to eliminate uncertainty — it's to take calculated bets and learn from the results.

A Framework, Not a Formula​

Here's a practical framework for thinking about engineering economics, short of full financial modeling:

  1. Measure the things you can. If you're building something, know the baseline. How long does this take now? How many users touch this? What's the current failure rate?

  2. Know your multipliers. A €60,000 feature for 2% of users might be worth it if that 2% represents your highest-value customers. A €60,000 feature for 50% of users might be a waste if those users don't pay.

  3. Distinguish between capability and output. Infrastructure that makes everyone 10% faster is different from a feature that drives direct revenue. Measure them differently.

  4. Track learning, not just outcomes. Did a feature fail because the market wasn't there, or because the execution was wrong? That's valuable data either way.

  5. Keep the meta-work minimal. If calculating ROI takes longer than building the feature, you're optimizing the wrong thing.

The Bottom Line​

Engineering organizations are flying blind — but maybe that's okay up to a point.

The extreme of no measurement is waste: teams working on things that don't matter for users who don't care, with no accountability for results.

The extreme of hyper-measurement is paralysis: every decision requires a business case, every feature needs a revenue forecast, every engineer becomes a part-time analyst.

The middle ground is pragmatic: Measure what you can, accept what you can't, focus on problems worth caring about, and trust that the outcomes will follow.

The €60,000 question isn't whether that feature for 2% of users was worth it. The question is: Did you learn something that makes the next decision better?


FAQ​

Q: How do I measure ROI for engineering work? A: Start with baselines. Measure before you change. For features, track adoption, retention, and revenue impact. For infrastructure, measure time saved, error reduction, or developer satisfaction. But accept that some value is unmeasurable — like team morale or strategic option value.

Q: What's the 3-5x rule for engineering ROI? A: It's a heuristic that a feature should generate 3-5x its cost to be worth building. If building costs €60,000, the feature should generate €180,000-€300,000 of value. But this rule misses long-term value, capability building, and option value — so use it as a filter, not a law.

Q: How does AI change software team economics? A: AI lowers the cost of code generation, which changes the relative value of engineering skills. As code becomes cheaper, product judgment, user empathy, and strategic thinking become more valuable. Teams should focus on what AI can't do: understanding problems deeply, making judgment calls, and building relationships with users.

Q: Should every feature need a business case? A: No. Hyper-measurement slows down innovation. A better approach: quick business cases for major bets, lightweight ROI tracking for routine features, and space for experimental work where the value is learning, not revenue.


About the Author: Arkin is a software engineer and startup founder building Orbits Studio. He writes about engineering economics, startup strategy, and the intersection of technology and business. Find him at arkin-dev.com.

· 6 min read
Arkin Eliezer Julijanto

Someone bought 30 WordPress plugins, sat on a backdoor for 8 months, then weaponized it through an Ethereum smart contract. Meanwhile, AI coding tools are getting persistent memory, agent orchestration platforms are blowing up on GitHub, and Cloudflare is rebuilding its entire CLI to be agent-first. Today's tech news roundup covers the intersection where developer tooling meets security — and why founders should be paying attention to both.