Product Differentiation and Anti-Involution: The Three Core Pillars of Good Technology
Competing only on subsidies, price cuts, and feature copying tends to trap tech products in homogeneous, zero-sum competition. This article presents a framework for building "good technology" around three engineering pillars—innovation, positive value, and practicality—and shows how they reinforce one another. Innovation means original problem discovery and a differentiated, hard-to-copy technical moat. Positive value means growing the market rather than only fighting for existing share, while delivering real benefits to users. Practicality means target users can adopt the product with a low barrier and keep using it over time. Along the way, the article includes illustrative pseudocode for assessing whether a product is truly innovative and truly useful, a table of adoption metrics with example collection fields, and a product review checklist. The goal is to turn vague impressions into observable, optimizable engineering signals, helping teams shift from competing on price to competing on value.
Introduction: The Key to Escaping Involution Is Building “Good Technology”
As escaping involution (excessive, zero-sum competition) becomes an industry consensus, tech products that compete for market share only through subsidies, price cuts, and feature copying easily fall into homogeneous competition. A truly sustainable product strategy is usually not “cheaper,” but more differentiated, more valuable, and harder for users to give up. Good technology is not about piling up concepts or chasing trends. It requires three engineering pillars at once: innovation, positive value, and practicality.
Here, innovation means more than “having new features”—it means the ability to identify original problems and a differentiated technical moat. Positive value means more than “looking valuable”—it means expanding the market and delivering real benefits to users. Practicality means more than “advanced technology”—it means target users can adopt it with a low barrier, a high success rate, and over the long term. Together, these three form an assessable, iterable, reusable framework for refining a tech product.
1. Innovation: Building a Differentiation Moat Others Cannot Quickly Copy
The opposite of innovation is not being behind—it is being easily replaceable. If a product’s core capability can be replicated by competitors within a few weeks, it can hardly avoid price competition. Real innovation usually builds depth across three layers.
1.1 Original Design: Start From User Problems, Not Competitor Features
The starting point of original design is not “competitors have this, so I must copy it,” but “what unsolved problem are target users actually facing?” Many teams first build a feature-comparison table and end up with a pile of features that “everyone has but nobody truly needs.” A more reliable approach is to start from real scenarios and use user interviews, behavioral data, usability testing, support tickets, and churn analysis to find pain points that existing solutions overlook.
Here is a minimal example: a team’s collaboration tool initially wanted to build a “prettier dashboard,” because competitors all had one. But interviews revealed that users’ real pain was not being unable to see data—it was not knowing who was responsible, when an issue would be handled, or whether something had been missed when an anomaly occurred. Behavioral data also showed that users spent the most time not “viewing data” but “tracking anomalies.” So the team shifted focus from visualization to “anomaly routing, ownership assignment, and automatic reminders,” forming a differentiated solution. This kind of design does not necessarily have more features, but it solves more specific, real problems.
1.2 Core Technology: Building a Hard-to-Copy Technical Moat
A technical moat is not a one-time investment but long-term accumulation. It may show up in algorithm efficiency, engineering stability, unit cost, data processing capability, system reliability, or security and compliance. For the same general-purpose capability, the differences between products are often large: some are slow but usable, some have high throughput and stability, and some are low-cost but need more resources. These differences are the source of a technical moat.
To judge whether core technology is deep enough, look at a few signals: Does it hold up under high concurrency or complex scenarios? Has it formed stable engineering methods? Does it deliver quantifiable cost reductions? Is it hard to catch up with simply by piling on features? Can it keep accumulating data, algorithms, tooling, or experience? A technical moat is not something you advertise—it is validated by time, scenarios, and engineering depth.
1.3 Differentiated “Solutions”: Solving the Same Problem With a Different Path
Innovation does not have to mean inventing something entirely new. It can also mean “solving the same problem through a different path.” When all players compete along the same route, switching paths can bring a generational difference in experience, cost, or efficiency. For example, for the same data-processing task, some go with centralized cloud, some with edge computing, and some with offline-first. For the same user-growth goal, some rely on ad spend while others rely on product-driven word of mouth. The value of a differentiated solution lies in giving users benefits that existing solutions cannot, thereby creating switching costs.
The following is a simplified illustration to help teams judge whether they have “real innovation.” It is not an automated decision system, but a review aid:
# Illustrative pseudocode: fields must be replaced with real business dataHIGH = 80def has_unique_user_pain(product):# Input: product dict containing at least user_pain_verified, target_segment, pain_score# Output: bool, whether a unique and high-value user pain point is verifiedreturn product.get("user_pain_verified", False)def technical_moat_depth(product):# Input: product dict containing at least moat_depth_score# Output: 0-100 technical moat depth score, weighted from patents, algorithms, stability, cost, etc.return product.get("moat_depth_score", 0)def solution_path(product):# Input: product dict containing at least solution_path# Output: solution path label, e.g., "workflow", "cloud", "edge"return product.get("solution_path", "unknown")def evaluate_innovation(product, competitors):original_problem = has_unique_user_pain(product)hard_to_copy = technical_moat_depth(product) >= HIGHdifferent_path = solution_path(product) not in [solution_path(c) for c in competitors]return {"is_real_innovation": original_problem and (hard_to_copy or different_path),"risk": "easier to fall into price competition" if not (hard_to_copy and different_path) else "lower",}
The core idea of this model is: if a product neither solves a unique problem nor has a hard-to-copy core capability, and its solution path is highly consistent with competitors, it is more likely to be treated as an ordinary commodity and drawn into price-based competition.
2. Positive Value: Letting Technology Improve the Industry and Users
The value of technology ultimately lands on people and industry efficiency. Positive value is not a moral slogan—it is an observable, quantifiable product outcome. It includes at least two dimensions: positive value for the industry and positive value for users.
2.1 Positive Value for the Industry: Grow the Pie, Don’t Just Fight for It
Price wars are usually a zero-sum game: grabbing users away from rivals. Positive innovation leans more toward creating incremental value: through new technologies, new scenarios, and new capabilities, it makes previously impossible things possible and lets teams that could not participate before join in. For example, when a technical capability lowers the barrier to innovation, more small teams can build applications that only large companies could build before, and the industry’s activity and overall output rise.
To measure positive value for the industry, focus on a few lenses: number of new scenarios, number of ecosystem partner integrations, upstream and downstream collaboration efficiency, magnitude of unit-cost reduction, user time saved, and how well long-tail industry needs are met. For instance, if a tech product helps a customer cut deployment time from two weeks to two days, reduce a certain error rate from 5% to 1%, or let an operation that used to require specialists be done by ordinary employees, all of these are industry-level positive value.
2.2 Positive Value for Users: Embedded in Real Life and Work Scenarios
The standard for positive value to users is actually quite simple: after using the product, did users save time, reduce errors, lower the barrier, or gain a capability they did not have before? If a tech product only “looks cool,” users try it a couple of times and then abandon it, so it can hardly create lasting value.
Good technology usually does not force users to learn complex concepts. Instead, it embeds capabilities into real tasks: automatically organizing evidence when writing reports, automatically locating anomalies during troubleshooting, automatically generating usable designs, and automatically identifying weak areas during learning. Whether a product is truly positive comes down to whether it makes users’ key tasks smoother, more reliable, and easier.
3. Practicality: Technology That Can Actually Be Used Is What Matters
Practicality is the most easily overlooked yet most critical pillar. No matter how advanced the technology, if target users cannot adopt it, do not want to use it, or give up halfway, its value approaches zero. A tech product cannot only ask, from an engineer’s perspective, “can we build it?” It must also ask, from the user’s perspective, “can they use it smoothly?”
3.1 Usability Over Technical Showmanship
Users do not care how complex the internal architecture is. They care about three things: whether it is easy to get started, whether results are predictable, and whether errors can be recovered from. A practical product usually has these traits: a clear first-use path that does not require reading lengthy docs; intuitive core operations with key states visible; and, when errors occur, clear messages, a rollback path, and remedies.
This can be validated through usability testing. It is recommended to prepare a task list, have target users complete key tasks in real scenarios, and record: task success rate, completion time, error rate, where users get stuck, reasons for abandonment, and whether remediation paths are clear. Do not only ask “do you find it easy to use”—look at whether users can independently complete the core actions.
3.2 Use Data to Validate “Whether It Is Really Being Used”
Practicality cannot rely on subjective judgment; it must be measured with metrics. The following are common metrics and example collection fields:
| Metric | Meaning | Example collection fields | Notes |
|---|---|---|---|
| Activation rate | Share of acquired users who complete a key action | User ID, signup time, first core-action time | Reflects onboarding smoothness |
| 30-day retention | Share still active on day 30 after first activation | User ID, active date, product version | Reflects long-term value |
| Core action completion | Share who complete the value action after entering the flow | Flow step, completion status, time spent | Reflects whether value is reached |
| Drop-off distribution | Which steps users churn at | Step ID, churn time, error code | Pinpoints experience gaps |
| Task success rate | Share completing independently in usability tests | Test task, result, number of assists | Assesses real usability |
Note that the thresholds below are only examples and should not be treated as universal conclusions. Different business types, product stages, user groups, and core-action difficulty all require calibration.
def is_truly_useful(metrics, benchmark):# metrics example fields: activation_rate, retention_d30, core_action_completion# benchmark is an example baseline, to be calibrated by business type, product stage, and user groupactivated = metrics["activation_rate"] >= benchmark["activation_rate"]retained = metrics["retention_d30"] >= benchmark["retention_d30"]completes_core = metrics["core_action_completion"] >= benchmark["core_action_completion"]if not activated:return "Onboarding cost may be too high; simplify the first-use path"if not completes_core:return "Users are not reaching the key step that delivers value; optimize guidance"if not retained:return "Long-term value needs validation; reassess whether the core scenario is a must-have"return "Real practicality is in place"benchmark = {"activation_rate": 0.40, # example value, not a universal conclusion"retention_d30": 0.20, # example value, to be calibrated with product cycle"core_action_completion": 0.60 # example value, to be calibrated with core-action difficulty}
The point of this judgment framework is to turn “whether it is practical” from a vague feeling into observable, optimizable, reviewable engineering metrics. Teams should assign metric owners, define data-collection methods, and set a review cadence so that metrics do not become mere decoration.
4. Synergy: An Executable Product Review Checklist
Innovation, positive value, and practicality are not isolated slogans but a closed loop: innovation decides whether a product has a differentiation moat, positive value decides whether it creates value, and practicality decides whether it can truly land. They also constrain one another: pursuing innovation must not sacrifice usability, pursuing practicality must not degrade into feature piling with no moat, and pursuing positive value must not become an unverifiable grand narrative.
Teams are advised to use the following checklist during product reviews:
| Review dimension | Question to answer | Innovation evidence / metrics | Owner | Review cadence |
|---|---|---|---|---|
| Innovation | Do we have something others cannot quickly copy? | Unique pain-point validation records, technical moat score, differentiated solution notes | Product manager / Tech lead | Monthly or per-release review |
| Positive value | Do we make the industry and users better? | New scenarios, partner integrations, cost reduction, time savings, evidence of user benefit | Product ops / Ecosystem lead | Monthly |
| Practicality | Can users really adopt it? | Activation rate, 30-day retention, core action completion, error rate, task success rate | Data analyst / Product designer | Weekly dashboard + biweekly review |
During review, teams cannot just say “we have many features.” They must provide evidence: Does innovation have a unique problem and a moat? Does positive value have quantifiable incremental gains? Does practicality have real data behind it? Without differentiation and a technical moat, a product is more likely to fall into price competition; without positive value, it is hard to sustain; without practicality metrics, it tends to stall at “looks beautiful.”
Conclusion: From Competing on Price to Competing on Value
The essence of escaping involution is not refusing to compete, but changing how you compete: from price to value, from feature comparison to technical moats, from concept packaging to real scenarios, and from short-term growth to long-term usability. For a tech team, the truly effective direction is to focus energy on original problems, core technology, differentiated solutions, user benefits, and adoption metrics.
When a tech product simultaneously has innovation that others cannot easily copy, positive value that improves both the industry and its users, and practicality that ordinary users can rely on over the long term, it is more likely to break out of homogeneous involution and form competitiveness that endures across cycles. Good technology is not a pile of specs—it is technology that truly solves problems and earns long-term trust.
FAQ
1. What is good technology?
Good technology usually has three traits: it solves a real and important problem, it forms a differentiation moat, and users can truly adopt it. A technical concept or a single highlight alone is not enough to qualify as good technology.
2. How do I judge whether a tech product has a differentiation moat?
Ask three questions: Does it solve a problem others overlook? Is the core capability easy to copy in the short term? Is the solution path structurally different from mainstream approaches? If all three are weak, the product is more likely to fall into homogeneous competition.
3. How should I choose practicality metrics?
Choose different metrics at different product stages. Early on, focus on activation and core-action completion; during growth, focus on retention and return visits; at maturity, focus on efficiency gains, cost reduction, and long-term user dependence. The key is that metrics should align with the product’s value.
4. What are common mistakes?
Common mistakes include: copying competitor features, treating technical showmanship as value, looking only at signups while ignoring retention, looking only at specs while ignoring task completion, and judging that “users will adopt it” without any data collection.
