Journalist Johnny Harris explores the seldom-discussed period from 1776 to 1789, when the first attempt to unite the 13 colonies failed miserably, and how we ended up with constructs like the electoral college. During those years, the young nation operated under the Articles of Confederation, leaving Congress with little power to govern, tax, or solve disputes.
Superfeet is now letting customers scan their feet with an iPhone to order custom 3D-printed insoles directly through superfeet.com. The service requires no separate app download and works on iPhone 13 or newer running iOS 26.
The mobile experience mirrors what’s been available at select specialty run retailers, where staff guide customers through a foot scan in person. Now that same scan can happen at home. After completing the guided scan, users can review their foot profile, including arch height and shoe size, preview a 3D rendering of their insoles, and add custom engraving to the heel. The finished data gets sent to Superfeet’s 3D-printing facility in Bellingham, Wash., where the insoles are manufactured to the customer’s specifications.
Credit: Superfeet
“This evolution allows us to deliver a level of individualized engineering that was once only possible through specialized in-person experiences, unlocking access to our most advanced one-of-one custom technology,” said Superfeet CEO Trip Randall. “By putting this power into the hands of consumers, we ensure that whether you are at home or on the go, the highest standard of personalized support is just a few clicks away.”
The insoles come in two foam options. SuperRev is a lightweight, thin design suited for tighter-fitting performance footwear. SuperRev Max uses a supercritical beaded foam matrix built for high-rebound cushioning and fits better in roomier running shoes. Both pair with a 3D-printed support cap shaped from the customer’s scan. That cap includes a custom arch profile matched to each foot’s geometry, a stability lattice that adjusts thickness based on body mass, and a heel cutout designed to reduce impact forces.
Customers who don’t have a compatible iPhone or who’d rather work with a specialist can still get scanned at select specialty run retailers nationwide. Superfeet hasn’t disclosed how many retail locations currently offer the in-store service.
Johnny FPV is known for capturing cinematic aerial videos with his precision drone flying. He was approached by Bobcat to shoot a video of their top-of-the-line ZT7000 lawnmower. With a Kawasaki FX engine, this ride-on, zero-turn mower can hit speeds up to 19 mph when it’s not cutting grass, and Johnny’s video makes this thing look like a true backyard beast.
Glock helped change what shooters expected from a modern service pistol: lighter weight, higher capacity, fewer controls, and rugged reliability. IMG Ryan Hodges
In today’s firearms market, it’s almost impossible to imagine a time before Glock. When polymer-framed semi-automatic pistols were not the norm.
Modern shooters can choose from an enormous variety of calibers, modular grip frames, optics-ready slides, and specialized features tailored for military service, law enforcement, self-defense, and recreational use. But turn the clock back to the mid-1980s, and the handgun landscape looked entirely different.
From the early 19th century onward, the revolver was America’s dominant handgun. Beginning with black-powder six-shooters and continuing through Samuel Colt’s 1873 “Peacemaker,” revolvers earned a reputation for mechanical reliability, cost-effective manufacturing, and cultural significance. These traits kept revolvers relevant well into the 20th century, even as many European nations transitioned to semi-automatic pistols. Law enforcement agencies continued issuing revolvers through the 1980s—typically short-barreled Smith & Wesson models chambered in .38 Special or .357 Magnum. While these guns lacked the ammunition capacity of contemporary semi-automatics, their simplicity and reliability kept them in police holsters for decades.
Manufacturers still built most semi-automatic pistols around traditional hammer-fired designs. They often featured heavy steel frames, blued finishes, and wood grips. Gunmakers treated them as finely machined mechanical tools—often beautifully crafted, but rooted in long-established design conventions. Companies such as Colt, SIG Sauer, Beretta, and Smith & Wesson dominated the market. Yet shifting law enforcement needs, evolving military requirements, and the unconventional thinking of an Austrian engineer would soon disrupt the handgun world forever.
By the late 1970s, the Austrian Army realized it needed a replacement for its aging World War II-era Walther P38. The new pistol needed to exceed the P38’s performance while meeting strict criteria: higher ammunition capacity, a maximum weight of 28 ounces, a light and consistent trigger pull, and a total parts count of no more than forty. These requirements pushed far beyond the standards of most handguns of the time.
Enter Gaston Glock. At the time, Glock operated a small manufacturing business in Vienna. Using a secondhand Russian metal press, the company produced brass door and window fittings before securing military contracts for field knives and bayonets. During visits to the Austrian Defense Ministry, Glock overheard discussions about the military’s search for a new service pistol. He instantly recognized an opportunity. But what did a curtain rod manufacturer know about designing firearms? Nothing—and that was precisely where Glock found success.
Unlike traditional firearms manufacturers, Glock was not constrained by decades of design convention or industry assumptions.
Glock later explained, “That I knew nothing was my advantage.”
Glock approached the challenge with methodical intensity. He purchased and disassembled a variety of modern handguns—including the Beretta 92F, SIG Sauer P220, CZ 75, and Walther P38—to study their strengths and weaknesses. In May 1980, he invited several firearms experts to his vacation home in Velden, Austria, and asked a simple question: “What would you want in a pistol of the future?” Their insights helped shape a revolutionary handgun design.
Rather than relying on traditional manufacturing techniques, Glock focused entirely on meeting the Austrian military’s performance requirements.
Simplicity, durability, light weight, and reliability became the guiding principles behind the pistol.
Glock’s use of a polymer frame became one of the pistol’s most significant innovations. Having worked with high-strength polymer materials while producing handles and sheaths for his military knives, Glock recognized the material’s potential for firearms manufacturing. Polymer construction dramatically reduced weight and manufacturing cost compared to the steel-framed pistols dominating the market.
Glock also broke from convention with his “Safe Action” trigger system. Instead of an external hammer and manual safety, the pistol used a striker-fired mechanism and a trigger-mounted safety lever. This design reduced snagging during the draw and lowered the chance of accidental discharges caused by drops or improper handling.
“Safe Action” trigger system. IMG Ryan Hodges
Development moved remarkably fast. Within a year, Glock produced a working prototype. On April 30, 1981, he filed a patent application for the seventeenth iteration of his design, which Glock simply named the Glock 17.
The Austrian Trials
The Glock 17’s unconventional design immediately drew skepticism. A polymer-framed pistol with no manual safety, no external hammer, and a striker-fired system seemed radical—especially coming from a manufacturer with no firearms pedigree.
During the Austrian trials, Glock’s pistol competed against established giants including Heckler & Koch, SIG Sauer, Beretta, Fabrique Nationale, and Steyr. The tests were grueling. Testers subjected each handgun to heat, ice, sand, mud, and a 10,000-round endurance test. Officials also evaluated the pistols on weight, capacity, and parts count.
The Glock 17 excelled in the tests. It malfunctioned only once during the firing trial and weighed just 23 ounces, making it the lightest pistol in the competition. The polymer frame and rolled-steel slide held up to abuse far better than skeptics expected.
Although the Glock lacked traditional aesthetic appeal, its utilitarian design perfectly matched the Austrian military’s requirements. Impressed by its performance and low manufacturing cost, the Ministry of Defense ordered 20,000 Glock 17 pistols in 1983. What began as a military contract would soon reshape the global handgun market.
Glock 19 Gen 4 Field Stripped. IMG Ryan Hodges
Glock Comes to America
Winning the Austrian trials was only the beginning. To reach its full potential, Glock needed to break into the American market.
While on a business trip in 1984, Austrian-American firearms salesman Karl Walter first encountered the Glock 17 and became intrigued by its design. At the time, many U.S. police departments still relied on revolvers, and Walter quickly recognized the Glock as a modern solution to growing law enforcement challenges.
Walter and American gun writer Peter G. Kokalis soon arranged a meeting with Gaston Glock. The conversation proved fruitful, and their partnership led to the establishment of Glock’s U.S. operations in Smyrna, Georgia, in 1985.
However, Glock’s introduction to the American market proved rocky from the start. Media outlets fueled fears about the “plastic gun,” claiming it could evade X-ray machines and pose a significant threat to aviation security. Congressional concern soon followed. Ultimately, authorities debunked the claims—but the controversy generated massive publicity. Ironically, the negative attention benefited Glock enormously. Millions of Americans suddenly became familiar with the strange Austrian pistol made largely from polymer. Law enforcement agencies took notice, and civilian shooters did too.
Glock 19 Gen 4. IMG Ryan Hodges
The Shift in Police Sidearms
The 1980s saw a sharp rise in violent crime in the United States. Drug trafficking, gang violence, and heavily armed criminals created increasingly dangerous encounters for police. Many departments realized their six-shot revolvers were becoming outmatched.
The turning point came with the infamous 1986 FBI Miami shootout, which left two agents dead and five wounded. Several agents armed with revolvers found themselves badly outgunned during the firefight. The incident accelerated the nationwide shift toward higher-capacity semi-automatic pistols.
The Glock 17 arrived at exactly the right moment. Lightweight, simple, durable, and offering 17+1 rounds, it provided a practical and affordable solution for agencies seeking modern sidearms. The Miami Police Department became one of the first major adopters, ordering 1,100 pistols. Soon, departments across the country followed.
While not the newest gun by Glock, the Gen 3 G17 is still a formidable pistol. IMG Jim Grant
From Duty Holster to Household Name
As Glock pistols spread through American law enforcement, their reputation grew. Shooters appreciated their reliability, simplicity, and ease of maintenance. The pistol’s distinctive appearance and rising popularity also made it a fixture in American pop culture.
Glock reached full pop culture status in Die Hard 2: Die Harder when Bruce Willis’ character John McClane shouted at an airport security guard, “That punk pulled a Glock 7 on me! You know what that is? It’s a porcelain gun made in Germany. Doesn’t show up on your airport X-ray machines, here, and it costs more than you make in a month!”
Nearly every detail in the quote was wrong—but the Glock name had officially entered the American lexicon. Soon, Glocks appeared in action films, television dramas, and rap lyrics. The brand became synonymous with the modern semi-automatic pistol.
Meanwhile, civilian shooters embraced the platform as well. Competitive shooters, instructors, and concealed carriers valued its durability and modularity. A massive aftermarket industry emerged, offering custom sights, triggers, holsters, and slide modifications. By the late 1990s, Glock had become one of the dominant handgun platforms in America.
The Polymer Revolution
Glock’s success did more than create a popular handgun—it changed the direction of the entire firearms industry. Before Glock, shooters viewed polymer-framed pistols with skepticism, and most manufacturers treated striker-fired systems as unconventional. Glock proved that a lightweight, durable, high-capacity polymer pistol could not only compete with traditional steel designs, but often outperform them. Combined with Karl Walter’s aggressive marketing strategy and excellent timing, Glock quickly became one of the most recognizable names in the global firearms industry.
Competitors across the industry soon followed. Smith & Wesson, SIG Sauer, Springfield Armory, FN, Walther, and numerous others introduced their own polymer-framed striker-fired pistols, many heavily influenced by Glock’s design philosophy. To this day, Glock’s design remains one of the most influential handgun developments of the modern era. Modular polymer-framed, striker-fired pistols now dominate the handgun market, and Glock pistols remain among the most widely carried law enforcement sidearms in the world.
Glock didn’t invent every concept found in the Glock 17, but the company combined proven ideas into a simple, reliable, affordable package that redefined consumer expectations.
Sources Referenced:
Barrett, Paul M. Glock: The Rise of America’s Gun. New York: Crown Publishers, 2012.
Ryan is an outdoorsman and firearms enthusiast with over a decade of experience in the industry. He holds a B.A. in History with a concentration in Public History from Roanoke College and was an intern at the Cody Firearms Museum in Cody, Wyoming where he contributed to exhibit development and public education initiatives. He later worked with Taylor’s & Co. in Winchester, Virginia for 9 years, building expertise in historical and reproduction firearms.
An avid hunter and shooter based in Northern Virginia and the West Virginia panhandle, Ryan has a deep appreciation for the intersection of history, firearms, and the natural world. His primary area of focus is 19th-century American firearms, particularly those used during the Civil War and the era of westward expansion. Through his writing, he aims to educate and engage readers by connecting the historical significance of firearms with their enduring legacy in the field today.
Database purchases are often considered just another IT expense. The primary concerns are limited to license fees and sign support contracts. But this mindset ignores hidden costs like downtime, excess capacity, rising renewal fees, and data transfer charges.
The financial sector particularly suffers, as proprietary databases hinder system updates for compliance and real-time AI, impose rigid pricing, and shift operational risk to the buyer.
Procurement leaders are starting to see this problem. Over 74% of Database as a Service (DBaaS) users cite high and unpredictable costs as their top challenge due to proprietary pricing structures. Meanwhile, the open source database market is projected to reach $63.48 billion by 2034, signaling a major industry shift.
Switching to open source databases offers procurement teams better financial control, allowing spending to be measured and predicted like any other asset.
This article provides a framework for procurement leaders to realize the ROI of open source databases. It explains how to move beyond license-focused sourcing to a strategy that prioritizes risk reduction, spend predictability, and vendor optionality.
The procurement blind spot: What database TCO really includes
License fees often become the total cost baseline in many sourcing cycles. But that license cost is only a fraction of the true database Total Cost of Ownership (TCO). The massive operational and strategic costs are hidden beneath the surface. The cost drivers show up in six areas:
Outage and SLA penalties: Downtime incurred due to vendor-managed recovery or architecture constraints.
Forced over-provisioning: Licensing models that require institutions to buy capacity they may not fully use (because licenses are sold in “blocks” or “cores”). If your workload requires 9 cores, you are often forced to pay for 16.
Escalating renewal pricing: Per-core or per-instance fees that climb with infrastructure growth, unrelated to feature value.
Data egress fees and platform taxes: Cloud DBaaS charges for cross-region replication, data exports, backups, and traffic that accumulate unpredictably.
Staffing and operational overhead: Database administrators and Site Reliability Engineers (SREs) dedicating time to tuning, patching, and managing vendor-specific tooling.
Migration and switching costs: The financial and technical burden of moving data if vendor changes or licensing terms shift.
Downtime as a financial liability (Not a technical issue)
Procurement teams may not always be the primary owners of downtime risk, but they often influence it through vendor selection, contract terms, and support coverage. Because outages carry measurable business impact, support responsiveness and recovery capability should be evaluated as a financial exposure.
For example, critical-incident response and restoration expectations must be defined and aligned with the organization’s risk tolerance. If not, the institution may be accepting avoidable financial and operational exposure during high-severity events.
For a bank with three major outages per year, averaging 4 hours each, with a $500K/hour impact:
3 × 4 × $500,000 = $6 million in annual downtime risk
Open source works best when supported by vendor-agnostic experts like Percona’s. It allows procurement to source support that focuses on restoring service across the entire stack, rather than defending a specific piece of software.
Cost predictability vs. vendor-driven cost escalation
Budget forecasting becomes impossible when database costs are unpredictable. Yet proprietary licensing introduces multiple mechanisms that undermine forecast accuracy and negatively affect business success.
The scaling penalty: As your customer base grows and you add more hardware, your software costs increase exponentially because of per-core or per-socket licensing.
Tier creep: You might start on a Standard tier, but as soon as you need a critical security feature like advanced encryption or granular auditing for DORA (Digital Operational Resilience Act) compliance, you are forced into an Enterprise tier that can cost more.
In contrast, open source separates the software cost from growth. If you double your infrastructure to handle peak trading volumes, your software cost remains zero. It lets procurement provide the business with a linear, predictable cost model (you only pay for the infrastructure you use and the expertise required to run it).
Vendor lock-in and contract leverage
The primary objective of a sales team from a proprietary vendor is to make customers more committed to their products. The more vendor-specific features you use, the harder it is for procurement to negotiate when renewing the contract. Over time:
Switching costs add up: Data migration, changing schemas, and application changes create high barriers to leaving.
Vendor leverage grows: As integration deepens, alternatives become more costly, reducing competition in renewal negotiations.
Renewal pricing rises: With fewer alternatives, vendors increase renewal fees, confident that institutions cannot easily leave.
Percona’s research on Redis users shows that nearly 75% have considered or tested alternatives when licensing terms change, but most couldn’t really switch. This is vendor lock-in at its most destructive, as institutions resent the vendor but cannot leave.
Open source gives institutions more options (restores vendor optionality). Procurement can regain power through:
Multi-vendor support: If one support provider underperforms or raises prices, you can move your support contract to another provider without migrating your data.
Deployment flexibility: Open source can run on-premise, in any cloud (AWS, Azure, GCP), or in a hybrid model.
Lower switching costs: Since open source uses standard protocols, it is easier to find talent and tools that work across the stack, and reduce the exit cost of any single relationship.
Operational efficiency as a budget control mechanism
Database operations often increase operating expenses. When teams react to problems rather than prevent them, labor costs rise without notice. Inefficient database management raises labor costs in two ways:
Specialized labor scarcity: Finding a specialist for a proprietary database is expensive.
Reactive engineering: When database performance is poor, teams spend more time fixing issues instead of building new products.
Switching to an open-source system with integrated management tools, like Percona Monitoring and Management, can help the organization save valuable engineering time.
For example, if a 10-person engineering team spends 20% of their time on manual database maintenance, that’s like paying two full-time employees just to keep things running. Improving tools and support reduces this work and provides immediate operational ROI.
Data egress fees: The hidden variable cost
In cloud services, it’s usually free to get your data in, but costs can skyrocket when you want to get your data out. Many managed proprietary DBaaS platforms are designed to trap your data. They make it easy to scale up, but charge massive data egress fees if you want to move that data to a third-party analytics tool or a different cloud provider.
Open source databases, particularly when run on Kubernetes or self-managed infrastructure, give you full control over the data path. With that control, procurement and platform stakeholders can design data flows that reduce unnecessary cross-cloud transfers and help minimize egress fees.
Annualized ROIs Summary for procurement
When presenting the move to open source to the executive team, procurement should frame the benefits across the following financial pillars:
ROI Lever
Procurement outcome
Financial impact
Risk avoidance
Reduced downtime frequency and duration.
Lowered black swan event liability.
Spend control
Removal of license multipliers.
Predictable, linear cost growth.
Leverage
Multi-vendor support options.
Stronger renewal negotiating power.
Productivity
Reduced manual DB management.
Reclaiming expensive engineering hours.
Why open source aligns with procurement objectives
Modern procurement is about governance, compliance, and strategic alignment. Open source databases align with these goals better than proprietary ones:
No licensing premiums for scale or performance. A 10x increase in data does not mean 10x higher license fees.
Transparent, auditable cost structures. Procurement knows exactly what they are paying for.
Support can be competitively sourced. Institutions are not locked into a single software vendor.
Better compliance and security. Open code enables internal security reviews, transparency for auditors, and helps meet regulatory requirements.
Operating open source with procurement-grade assurance
A common objection to open source is that it’s unsupported. Procurement teams need operational assurance, confidence that open source environments meet the same regulatory, availability, and financial standards as proprietary systems.
When evaluating a support partner, procurement should require:
SLA clarity: Specific, contractually backed response and resolution times.
Multi-database coverage: One contract that covers MySQL, PostgreSQL, and MongoDB to reduce contract sprawl.
Regulated-environment experience: A partner who understands PCI-DSS, SOC2, and the high-compliance needs of finance.
Percona meets all of these criteria and offers procurement with a partner that turns technical operations into financial metrics.
Where Percona fits
Percona operationalizes open source databases for regulated, mission-critical environments. It delivers measurable outcomes across four strategic dimensions for procurement teams:
Independent, vendor-neutral support model
Percona provides technology-agnostic support across MySQL, PostgreSQL, MongoDB, MariaDB, and Valkey. It operates independently of cloud providers and database vendors, supporting on premises, cloud, and hybrid environments. This vendor neutrality ensures institutions maintain full control over technology choices without being locked into specific platforms or ecosystems.
Predictable support costs without licensing dependency
Percona’s pricing model decouples support costs from database licensing and creates transparent, forecastable expenses. While proprietary databases force organizations to pay escalating per-core or usage-based fees, Percona’s support subscriptions operate independently of infrastructure growth. For example, organizations like BBVA reduced licensing and support costs while simultaneously improving backup performance by 20% after migrating to Percona Server for MongoDB.
Proven experience supporting regulated financial systems
Percona supports regulated financial systems, including Fortune 500 companies and government agencies, and meets compliance standards such as HIPAA, PCI DSS, GDPR, and DORA EU.
Major financial services implementations include:
Merchant Warrior: Australia’s payments gateway relies on Percona for critical MySQL availability, supporting millions of transactions across 30,000+ customers.
MultiPay and Bukalapak: Financial services and e-commerce platforms leveraging Percona’s support to maintain high availability and optimize deployment performance.
Conclusion: Database performance as a spend control strategy
Databases have evolved from technical infrastructure into financial assets. Their uptime, performance, and flexibility influence costs, vendor leverage, and operational resilience. For procurement, buying databases is a strategic investment to control expenses and manage risks.
Organizations gain predictable costs, measurable ROI, vendor optionality, and long-term operational control by choosing open-source databases and partnering with Percona. These advantages compound over time, while proprietary systems often fall short.
Get started with Percona Operators and see how consistency, scale, and freedom come together.
When we introduced MySQL Studio, the goal was to bring the common parts of database development and analysis into one OCI workspace: SQL authoring, schema exploration, results visualization, and Ask Studio. The next step is making that workspace more useful during the everyday flow of MySQL work. For many MySQL developers, DBAs, and application teams, […]Planet MySQL
There’s a phrase in enterprise software: “Eat your own dog food.” It means you should be using the software you’re developing internally, because you find bugs more quickly that way.
Last year, Microsoft CEO Satya Nadella revealed that the company writes up to 30% of its code using generative AI. As it now happens, Microsoft is reportedly planning to reduce the use of Anthropic’s Claude Code — a move designed to push its employees toward GitHub Copilot CLI.
For context, The Verge’s Tom Warren reported that Microsoft started opening access to Claude Code for its employees in December, including developers, project managers, and designers, allowing them to interact and experiment with the AI-coding assistant directly in their workflows.
Warren reports that Claude Code gained vast popularity among Microsoft employees over the past six months, which has seemingly led to a pullback on its Claude Code push in favor of its own GitHub Copilot CLI. “While Claude Code has been a popular addition, it has also undermined Microsoft’s new GitHub Copilot CLI coding tool,” Warren explained.
According to Warren’s sources, Microsoft’s Experiences + Devices division, which includes teams working on Windows, Microsoft 365, Outlook, Teams, and Surface, is supposed to stop using Claude Code by the end of June. These teams are expected to transition their workflows to GitHub Copilot CLI over the next few weeks.
The report reveals that the decision isn’t centered on Microsoft pushing its staffers towards its own offering — there are some financial implications at play, too. Microsoft’s financial year is expected to end on June 30, which means canceling Claude Code licenses for its employees could cut its operational costs as it transitions into a new financial year.
While speaking to The Verge, Microsoft’s VP of experiences and devices group, Rajesh Jha, indicated:
“When we began offering both Copilot CLI and Claude Code, our goal was to learn quickly, benchmark the tools in real engineering workflows, and understand what best supported our teams. Claude Code was an important part of that learning… at the same time, Copilot CLI has given us something especially important: a product we can help shape directly with GitHub for Microsoft’s repos, workflows, security expectations, and engineering needs.”
It’ll be interesting to see how the transition from Claude Code to GitHub Copilot CLI is received, especially since the vast majority seems to favor the former. The company’s initial plan was to have its engineers use both offerings concurrently, to compare their capabilities, and to provide feedback.
Interestingly, Microsoft staffers have seemingly preferred Claude Cove over GitHub Copilot over the past few months, primarily because of the feature disparity between the two products.
I wondered if “Claude Cove” was a typo, but no, it’s apparently a real thing.
An opportunity for a really obscure meme.
These sorts of stories pop up again and again: Everyone who is forced to use Copilot seems to hate it. Claude doesn’t seem to generate the same level of loathing, maybe because Anthropic doesn’t have the same opportunities Microsoft does to shove it down the throats of its existing users.
Now we know that Microsoft’s Devs, just like its users, seem to prefer the taste of other people’s dog food over Microsoft’s…
HELL — Satan confirmed this week that he was, in fact, responsible for raisins.
Speculation had run rampant for thousands of years of human history regarding the origin of the alleged "dried grapes," but the Father of Lies held a press conference on Tuesday to take full credit.
"Ooooh, yeah. That was me," the Prince of Darkness said. "I did that. Those little tiny BBs of gritty, overly sweet nastiness? Yep. Totally me. I thought about what I could inflict on the Earth and its inhabitants that would unleash maximum frustration and disgust, and it just sort of came to me."
The Devil admitted to reporters he spent years trying to think of something that would be more universally hated, admitting that he originally tried to come up with an odious snack, something like dried seaweed, but realized that the hippies had cornered that market years ago.
"Then one day it came to me: let’s take grapes, which everyone loves, and dry the heck out of them, and then sell them in little boxes and market them as healthy snacks. It was a devilish idea, if I do say so myself. Pun very much intended."
Satan said it was also he who came up with the idea to put raisins in oatmeal cookies and make them look like chocolate chips.
"Yes, yes, that was a good one. No one even saw it coming. I still can’t believe I pulled it off."
At publishing time, Satan had also taken credit for mosquitos, people talking on their speakerphones in public, meetings that could have been emails, and The View.
Every hour a racist loses hope, will you help the Southern Poverty Law Center to help a racist in need?
-- Every hot-path query carries customer_id, so it routes to one shard.
SELECT * FROM orders
WHERE customer_id = 88213 -- shard key: single-shard lookup
AND status = 'shipped'
ORDER BY created_at DESC;
The trade-off to accept consciously is that cross-shard-key queries become expensive. Analytics that aggregate across all customers, admin searches by email, or reports spanning every tenant cannot be answered from a single shard. The pattern is not to avoid these but to serve them differently: route analytical queries to a separate columnar store or data warehouse, maintain secondary lookup tables for the few alternate access paths you truly need, and accept that the operational database is optimized for its dominant access pattern, not every possible one.
Even if you are not sharding today, choosing and consistently populating a shard key now means that when you do shard, it is a routing change rather than a schema migration across billions of rows.
Pattern 3: Denormalize Deliberately to Kill the Join Fan-Out
Normalization is the right default. It prevents update anomalies and keeps each fact in exactly one place. But the relational join—the mechanism that makes normalization work—is precisely the operation that does not partition cleanly. A join between two tables on different shard keys forces a cross-shard operation. Even on a single server, a query that joins five tables to render one screen multiplies the work and the lock surface.
The scalability pattern is targeted denormalization: duplicate the specific fields that hot-path queries need so those queries can be answered from a single row or a single table, without joins.
The discipline here matters. Indiscriminate denormalization creates a maintenance nightmare where every update has to touch a dozen copies. The pattern is to denormalize only the fields that appear together in your highest-volume read paths, and to be explicit about which table owns the source of truth versus which holds a cached copy.
-- Instead of joining orders -> customers on every order list view,
-- store the small, slowly-changing customer fields the list needs.
CREATE TABLE orders (
id BIGINT UNSIGNED NOT NULL,
customer_id BIGINT UNSIGNED NOT NULL,
customer_name VARCHAR(120) NOT NULL, -- denormalized copy
customer_tier TINYINT NOT NULL, -- denormalized copy
total_cents INT UNSIGNED NOT NULL,
created_at DATETIME(3) NOT NULL,
PRIMARY KEY (customer_id, id)
) ENGINE=InnoDB;
When the source data changes (a customer renames their account), you update the copies asynchronously—via application logic, a change-data-capture pipeline, or a background job. The key insight is that for many fields the consistency requirement is “eventually,” not “immediately,” and trading a small consistency window for join-free reads is exactly the trade that buys linear read scalability.
A common and powerful variant is the read model or materialized view table: a table whose sole purpose is to serve one expensive query shape, populated by aggregating or flattening normalized source data. The write path stays normalized; the read path gets a purpose-built, join-free table.
Pattern 4: Split Tables Vertically to Keep Hot Rows Small
InnoDB reads and writes data in 16 KB pages. The narrower your rows, the more rows fit per page, the more of your working set fits in the buffer pool, and the less I/O each query costs. A wide table—dozens of columns including large TEXT, JSON, or BLOB fields—wastes buffer pool space on data that most queries never touch.
Vertical partitioning splits one wide table into a narrow “hot” table and one or more “cold” tables, joined by the same primary key. The columns accessed on every request stay in the slim hot table; the rarely-read bulk moves to a companion table.
-- Hot table: tiny rows, queried constantly, fits entirely in memory.
CREATE TABLE users (
id BIGINT UNSIGNED PRIMARY KEY,
email VARCHAR(255) NOT NULL,
status TINYINT NOT NULL,
last_login_at DATETIME(3),
UNIQUE KEY (email)
) ENGINE=InnoDB;
-- Cold table: large, rarely-read fields kept out of the hot path.
CREATE TABLE user_profiles (
user_id BIGINT UNSIGNED PRIMARY KEY,
bio TEXT,
preferences JSON,
avatar_blob LONGBLOB,
CONSTRAINT fk_profile FOREIGN KEY (user_id) REFERENCES users(id)
) ENGINE=InnoDB;
This pattern is especially valuable for tables that mix frequently-updated columns with large static ones. Updating a single counter on a row that also holds a megabyte JSON document means InnoDB may rewrite far more than the changed bytes and generate large undo and redo records. Separating volatile small columns from stable large ones reduces write amplification and replication payload, both of which directly affect how far you can scale writes.
Pattern 5: Use Native Partitioning for Time-Series and Lifecycle Data
Not all scaling is horizontal across servers. A single MySQL instance can manage far larger tables when the table is partitioned internally so that queries and maintenance touch only the relevant slice. MySQL’s native PARTITION BY RANGE on a date or sequential ID is the canonical pattern for time-series, event, and log-style data.
The benefits compound at scale. Queries with a date predicate undergo partition pruning—the optimizer skips every partition outside the range, so a query over last week’s data never scans last year’s. Equally important, dropping old data becomes instant: ALTER TABLE ... DROP PARTITION is a near-metadata-only operation, compared to a DELETE that would scan, lock, and log millions of rows and bloat the table.
CREATE TABLE events (
id BIGINT UNSIGNED NOT NULL,
user_id BIGINT UNSIGNED NOT NULL,
event_type VARCHAR(40) NOT NULL,
created_at DATETIME NOT NULL,
PRIMARY KEY (id, created_at) -- partition column must be in the PK
)
PARTITION BY RANGE (TO_DAYS(created_at)) (
PARTITION p2026_05 VALUES LESS THAN (TO_DAYS('2026-06-01')),
PARTITION p2026_06 VALUES LESS THAN (TO_DAYS('2026-07-01')),
PARTITION p2026_07 VALUES LESS THAN (TO_DAYS('2026-08-01')),
PARTITION pmax VALUES LESS THAN MAXVALUE
);
Two constraints shape this pattern. The partitioning column must be part of every unique key, including the primary key—hence (id, created_at) above. And partition maintenance (adding next month’s partition, dropping the oldest) should be automated, because a partitioned table that runs out of defined ranges or accumulates unbounded partitions reintroduces the very problems it was meant to solve. Treat partition rotation as a scheduled operational job, not a one-time DDL.
Pattern 6: Eliminate Write Hotspots and Contention Points
A hotspot is any single row, page, or counter that a large fraction of writes must touch. Hotspots are the enemy of linear scaling because they serialize writes that should run in parallel—no amount of added hardware helps when everything queues behind one lock.
The most common hotspot is the global counter: a single row holding a total that every transaction increments, such as a “likes” count on a viral post or a balance on a shared account. Under load, every writer contends for the lock on that one row.
The fix is the sharded counter pattern. Instead of one row, maintain N rows and have each writer increment a randomly or hash-chosen shard. The true total is the sum across shards, computed at read time (or periodically rolled up).
CREATE TABLE post_like_counters (
post_id BIGINT UNSIGNED NOT NULL,
shard TINYINT UNSIGNED NOT NULL, -- e.g. 0..63
likes BIGINT UNSIGNED NOT NULL DEFAULT 0,
PRIMARY KEY (post_id, shard)
) ENGINE=InnoDB;
-- Writes spread across 64 rows instead of contending on one:
UPDATE post_like_counters
SET likes = likes + 1
WHERE post_id = 991 AND shard = FLOOR(RAND() * 64);
-- Reads aggregate (cache the result if needed):
SELECT SUM(likes) FROM post_like_counters WHERE post_id = 991;
Related hotspot patterns worth internalizing: prefer append-only inserts over in-place updates where the domain allows it, because inserts to ordered keys contend far less than updates to shared rows; avoid status-flag columns that the entire fleet polls and updates in lockstep; and be wary of “queue” tables where every worker hammers the same few “ready” rows—use techniques like SELECT ... FOR UPDATE SKIP LOCKED to spread workers across rows. Each of these is the same lesson: find the shared point and break it into many independent points.
Pattern 7: Index for the Working Set, Not Every Possible Query
Indexes accelerate reads but tax writes—every secondary index must be updated on insert, and in InnoDB each one carries the full primary key as its row pointer. On a write-heavy table at scale, an over-indexed schema can spend more effort maintaining indexes than storing data, capping write throughput.
The scalable approach is to index for your actual hot query shapes and prune the rest. A few principles carry most of the value:
Composite indexes should match query order. An index on (customer_id, status, created_at) serves equality-on-customer-then-status-then-range-on-date queries efficiently, following the leftmost-prefix rule. The column order should mirror how predicates are applied.
Covering indexes eliminate row lookups. If an index contains every column a query needs, InnoDB answers the query from the index alone, never touching the clustered index. For high-frequency queries, designing a covering index is one of the highest-return optimizations available.
Keep secondary indexes narrow, because every one of them stores the primary key. This is another reason fat primary keys (random UUIDs) hurt: they bloat not just the table but every index on it. A compact key keeps the whole index footprint small enough to stay in memory.
Periodically audit for unused and redundant indexes. An index that no query uses is pure write overhead. At scale, removing it can measurably lift write throughput—a rare optimization that costs nothing and helps everywhere.
Pattern 8: Model for Replication and Eventual Consistency from Day One
Linear read scaling on MySQL almost always means read replicas: a primary handles writes, and reads spread across replicas. This works beautifully—until the schema and the application assume read-your-own-writes consistency that asynchronous replication cannot guarantee.
The schema-level pattern is to make data tolerant of replication lag. Avoid designs that require reading a value immediately after writing it on a different node. Where read-after-write matters (a user updating their own profile and expecting to see the change), route those specific reads to the primary, and design the schema so that the set of such “must-be-fresh” reads is small and well-defined rather than pervasive.
This also influences how you model derived data. Counters, aggregates, and denormalized copies (Patterns 3 and 6) are naturally eventually-consistent, which fits replication well. Trying to keep them transactionally exact across replicas reintroduces coordination. Embracing eventual consistency for the data that can tolerate it is what lets the read tier scale out linearly.
A practical corollary: keep transactions short and touch as few rows as possible. Long, wide transactions hold locks longer, generate large binlog events, and widen replication lag—all of which erode the headroom replicas give you. Schema choices that naturally lead to small, focused writes (narrow hot tables, append-only patterns, sharded counters) pay off again here.
Pattern 9: Bound Every Table’s Growth
An unbounded table is a deferred outage. A table that grows forever will eventually exceed the buffer pool, then sensible index sizes, then maintenance windows, until routine operations like adding a column or rebuilding an index become multi-hour ordeals. Linear scalability assumes you can keep adding capacity; an unbounded table eventually makes each unit of capacity more expensive than the last.
The pattern is to design a retention and archival strategy into the schema itself, not bolt it on later. Time-range partitioning (Pattern 5) is the cleanest mechanism: old partitions drop instantly. For data that must be retained but not served hot, move it to cheaper archival tables or external storage on a schedule, keeping the operational table sized to the working set. Define, in writing, how large each high-growth table is allowed to get and what happens when it approaches that limit—before the table forces the answer on you at the worst possible time.
Bringing the Patterns Together
These patterns reinforce one another, and the through-line is consistent. Distribution-friendly primary keys make sharding possible. A well-chosen shard key makes the dominant queries single-shard. Deliberate denormalization and read-model tables remove the joins that would otherwise force cross-shard work. Vertical partitioning and tight indexing keep the hot working set in memory. Native partitioning and bounded growth keep individual tables fast and maintainable. Hotspot elimination and replication-aware modeling remove the serialization points that flatten the scaling curve.
The unifying principle is worth restating because it is the thing to carry into your own design reviews: scalability is the absence of shared bottlenecks. Every pattern here is a way of taking something that wanted to be a single shared point—one counter, one global ID, one wide row, one giant table, one join across everything—and turning it into many independent things that can live on many machines. When you can add a server and the work genuinely spreads, you have linear scalability. When every server still has to consult the same hot resource, you do not, no matter how much hardware you buy.
The expensive truth is that almost all of this is far cheaper to do early. Retrofitting a shard key onto a billion rows, re-keying a clustered index, or splitting a table that the entire application reads from are migrations measured in weeks and risk. Sketching the schema with these patterns in mind from the start costs a few extra hours of thought. That trade—hours now against weeks later—is the best return available in database engineering.
Frequently Asked Questions
Does MySQL scale linearly out of the box? No. MySQL gives you the tools—replication, partitioning, and a flexible schema—but linear scalability is a property of how you model and access your data, not a default behavior. A poorly designed schema will hit a ceiling regardless of MySQL version or hardware.
Should I shard from the beginning? Usually not. Premature sharding adds operational complexity before you need it. The realistic advice is to choose and populate a shard key from the start so that sharding later is a routing change rather than a schema rewrite, while running on a single primary with read replicas until the data or write volume genuinely requires splitting.
Is denormalization always bad for data integrity? Denormalization trades some integrity guarantees for read performance and partitionability. The risk is managed by being explicit about which table owns each fact, denormalizing only hot-path fields, and updating copies through a reliable asynchronous mechanism. For data that tolerates eventual consistency, the trade is usually worth it at scale.
What primary key should I use for a distributed MySQL system? A time-ordered, coordination-free identifier such as UUIDv7, a ULID, or a Snowflake-style 64-bit ID. These preserve insert locality (unlike random UUIDv4) while remaining globally unique without a central counter (unlike plain auto-increment).
When should I use native partitioning versus sharding across servers? Use native partitioning when a single server can hold the data but individual tables have grown large, especially time-series data where partition pruning and instant partition drops help. Shard across servers when a single primary can no longer handle the write volume or total data size, regardless of partitioning.
