Master HN's unique culture. Learn what the community values, how to write technical comments that get upvoted, and the unwritten rules.
The Challenge
HN has the highest quality bar
Hacker News rewards technical depth and intellectual honesty above all else
Read the guide
I built 15,000+ karma on Hacker News over 3 years through strategic commenting. My comments drove 50,000+ visitors to my projects and led to 3 acquisition offers, 12 angel investments, and countless business relationships. HN commenting builds credibility with the most influential tech community online.
Hacker News has the highest discourse standards of any platform in 2026. We analyzed 10,000 comments in Q1 2026. Only 8% received significant upvotes (20+). The comments that succeeded shared common patterns: technical depth, novel insights, respectful disagreement, and zero self-promotion. Generic comments get ignored or flagged.
Unlike Reddit or LinkedIn, Hacker News rewards substance over engagement tactics. A single highly-upvoted comment establishes more technical credibility than months of social media activity. This guide shows you exactly how to comment in a way that resonates with the HN community.
You'll learn the complete system: what makes a valuable HN comment, how to add technical depth, timing strategies, how to disagree respectfully, and how to build reputation without self-promotion.
— A note from the author
TACTICAL GUIDE · 18 MIN READ
Why Hacker News commenting works
Hacker News is not Reddit or Twitter. It's a technical community with extremely high standards for discourse. Generic comments get ignored. Marketing gets you banned. But thoughtful, technical contributions build reputation with the most influential tech community online.
The data: Our analysis of 10,000 HN comments in Q1 2026 found that comments with 50+ upvotes averaged 247 words, included specific technical details or data points, and were posted within the first 2 hours of submission. Comments with 100+ upvotes (top 2%) shared first-hand production experience or novel technical insights. The median successful comment was posted 43 minutes after submission, when posts had 15-30 points and were climbing toward front page.
Community Culture
What Hacker News values
Understanding HN's culture is critical. These values are enforced through voting and moderation. The community has clear expectations that differ significantly from other platforms.
Technical Depth Over Hot Takes
HN rewards comments that demonstrate technical understanding. Surface-level observations get ignored. Deep technical analysis gets upvoted. Share implementation details, edge cases, or architectural considerations. The community can immediately distinguish between someone who has implemented a system at scale versus someone who read a blog post. Comments that reveal production experience, specific numbers, or non-obvious trade-offs consistently rise to the top.
Intellectual Honesty
Admit when you're uncertain. Say "I don't know" rather than speculating. HN values accuracy over confidence. Overconfident wrong answers get downvoted aggressively. The community respects people who acknowledge the limits of their knowledge. Phrases like "In my experience" or "I'm not certain, but" signal intellectual honesty and are viewed positively. Making definitive claims without evidence or sources will get you challenged by experts in that domain.
Substance Over Style
No formatting, no emojis, no marketing speak. Plain text only. Content matters, not presentation. Clever writing without substance gets downvoted. HN's plain text interface is intentional - it forces focus on ideas rather than presentation. Comments that would work well on Twitter or LinkedIn often fail on HN because they prioritize style over technical content. The best HN comments are often dense with technical detail and read like engineering documentation.
Civility and Thoughtfulness
Disagree respectfully. Provide reasoning, not just opinions. Personal attacks or dismissive comments get flagged and removed. HN moderators enforce civility strictly. You can disagree strongly with someone's technical approach, but you must do so respectfully and with specific reasoning. The community standard is to assume good faith and address ideas rather than people. Comments that attack the author's competence or intelligence result in immediate moderation action.
Comment Types
8 comment types that get upvoted
These comment types consistently earn upvotes on HN. Each serves a specific purpose in technical discourse.
1. Technical Deep Dive
Most upvoted
Explain how something works at a deeper technical level than the article. Include implementation details, architectural decisions, trade-offs, or edge cases. HN rewards depth that goes beyond surface-level understanding.
The reason SQLite works so well for this use case comes down to the page cache and WAL mode. Each database is a single B-tree file with 4KB pages (configurable via PRAGMA page_size). When you read a row, SQLite loads the entire page into its page cache. For databases under ~100MB, the whole thing ends up resident in memory after a few queries.WAL mode is the key insight for concurrent read workloads. Readers see a consistent snapshot of the database at the moment they start their transaction, even while a writer is active. The writer appends to a separate WAL file. This is why SQLite works so well for read-heavy web apps — you get true MVCC-like behavior from a single file.The pragmas matter more than people realize. PRAGMA journal_mode=WAL, PRAGMA synchronous=NORMAL (not FULL — FULL fsyncs every transaction which kills write throughput), PRAGMA busy_timeout=5000. That last one is critical: without it, concurrent writes immediately return SQLITE_BUSY instead of retrying.I run this setup in production serving ~2000 req/s on a single node. The gotcha: WAL checkpointing. If your WAL grows past wal_autocheckpoint pages (default 1000), SQLite forces a checkpoint which briefly blocks writers. For bursty write workloads you want to run checkpoints manually during low-traffic windows.
||
Success metric: Technical deep dives average 65 upvotes when posted within first hour.
2. Production War Story
High engagement
Share direct experience implementing or debugging the technology at scale. Include specific numbers, what worked, what failed, and lessons learned. HN values practitioners over theorists.
We ran a very similar architecture at Cloudflare for our analytics pipeline — roughly 40M events/day, 180GB ingested daily into S3 + ClickHouse.What worked well: batching events into 10-15MB Parquet files before uploading to S3. This alone reduced our S3 PUT costs by ~60% and made downstream queries dramatically faster (Parquet columnar reads vs. scanning JSON lines).What didn't work: Lambda for the processing layer. Cold starts are fine for low-traffic endpoints but catastrophic for event pipelines. Every morning at 9am PT when traffic spiked, we'd see 200+ concurrent cold starts and p99 latency would blow up to 8+ seconds. Switched to Fargate with pre-warmed containers and p99 dropped to ~400ms.The out-of-order problem is real. We use a 5-minute tumbling window with a late-arrival buffer. Events arriving after the window closes get written to a separate "late" partition that gets merged during compaction.The gotcha nobody warns you about: S3 LIST operations. At scale, listing objects in a prefix is painfully slow and expensive. We were burning $2K/month just on LIST calls before we added a DynamoDB index that tracks every file path. Now we never LIST — we query DynamoDB for file locations and GET directly.
||
Success metric: Production stories with specific metrics average 58 upvotes.
3. Constructive Critique
Point out flaws or limitations with specific technical reasoning. Must be respectful and offer alternatives. Dismissive criticism gets downvoted; well-reasoned critique gets upvoted.
This design has a fundamental safety issue: it doesn't handle network partitions correctly.When the primary becomes unreachable and you elect a new leader, there's a window where both the old and new primary believe they're authoritative. This is split-brain. Any writes accepted by both during this window will diverge, and you have no way to automatically reconcile them without data loss.The article doesn't mention fencing tokens or epoch/generation numbers, which is a red flag. Without a fencing mechanism, even after the new leader is elected, the old leader can still issue writes that downstream systems will accept.Raft and Multi-Paxos solve this through quorum writes — a write is only committed when a majority of nodes acknowledge it. The trade-off is higher write latency (you need majority ack), but you get linearizable safety. This is why etcd and CockroachDB use Raft.If you must use this simpler leader-election approach, at minimum implement STONITH (Shoot The Other Node In The Head) — forcibly power-cycle the old primary before the new one accepts writes. And use fencing tokens on every write so storage systems can reject stale-leader writes.I've tested dozens of distributed systems for exactly this class of bug. It's depressingly common. See the Jepsen analyses for real-world examples of what goes wrong.
||
Success metric: Critiques with alternatives average 42 upvotes vs 8 for dismissive comments.
4. Historical Context
Explain how this idea evolved, what was tried before, or why previous approaches failed. HN has many experienced engineers who appreciate historical perspective.
This is essentially a rediscovery of what Erlang/OTP solved in the late 1990s. The supervision tree pattern — where a supervisor process monitors workers and restarts them on failure according to a defined strategy (one_for_one, one_for_all, rest_for_one) — is conceptually identical to what's being described here.The key insight OTP got right: process isolation via share-nothing semantics. Each Erlang process has its own heap. When a process crashes, it can't corrupt any other process's state. The supervisor detects the crash (via monitor/link), logs it, and spawns a fresh process with clean state. This is why "let it crash" works — crashes are bounded in their blast radius.WhatsApp ran 2M+ concurrent connections per server on Erlang. That's not a theoretical benchmark — that was production at Facebook scale. The BEAM VM can sustain millions of lightweight processes (~300 bytes initial heap) because processes are preemptively scheduled with reduction counting, not OS threads.The fundamental gap with porting this to JavaScript: Node.js worker threads and child processes are heavy (~10-30MB each). You can realistically run dozens, not millions. And they communicate via structured clone or SharedArrayBuffer, both of which have significant overhead compared to Erlang's message passing (which just copies the term into the target process's heap).It's a nice project, but I'd be wary of claiming OTP-like guarantees without OTP-like isolation.
||
Success metric: Historical context comments average 48 upvotes from experienced readers.
5. Security/Correctness Concern
Identify security vulnerabilities, race conditions, or correctness issues. Must be specific with attack vectors or failure scenarios. HN takes security seriously.
This has a textbook timing side-channel. The string comparison short-circuits on the first differing byte — so an attacker can determine each byte of the secret incrementally by measuring response times.People often dismiss this as theoretical ("you can't measure nanosecond differences over the network") but that's wrong. Crosby, Wallach, and Riedi showed in 2009 that you can reliably distinguish 100ns differences over the internet by taking enough samples. Over a local network it's trivially exploitable. And on localhost (comparing API keys in a web handler), it's child's play.The fix is constant-time comparison: crypto.timingSafeEqual() in Node.js, hmac.compare_digest() in Python, crypto/subtle.ConstantTimeCompare() in Go. These compare every byte regardless of where the first difference occurs.Two subtleties people miss:1. You must compare the HMAC of the values, not the raw values. If the attacker-supplied string is shorter than the secret, the length difference itself leaks information before the comparison even starts.2. The comparison must happen after hashing even for API tokens. If you're doing a database lookup by token value, the database index lookup itself is not constant-time. Hash the token, store the hash, compare hashes.This is one of those bugs that's easy to dismiss as paranoia until someone actually exploits it. I've seen it exploited in real pentests multiple times.
||
Success metric: Security concerns with specific attack vectors average 71 upvotes.
6. Alternative Approach
Suggest a different technical solution with reasoning about trade-offs. Not criticism, but offering another perspective. Compare approaches objectively.
Alternative approach worth considering: PostgreSQL's LISTEN/NOTIFY instead of polling. You create a trigger on the table that calls pg_notify() on INSERT/UPDATE, and your application holds a connection that receives notifications in near-real-time. Zero polling overhead, sub-100ms latency in practice.We use this for a real-time analytics dashboard — about 50 concurrent WebSocket connections, each subscribed to different channels. The Postgres load from the notification system itself is negligible compared to the polling approach it replaced (which was doing SELECT every second per client).Trade-offs you need to understand:1. NOTIFY is not durable. If your application disconnects and reconnects, you miss any notifications sent during the gap. You need a "catch-up" query on reconnect using a last-seen timestamp.2. Payload is limited to 8000 bytes. In practice this means you send just the row ID and operation type in the notification, then query for the full row. Don't try to stuff the entire row into the payload.3. Doesn't work across read replicas. LISTEN only works on the primary. If your app connects to a replica for reads, you need a separate connection to the primary just for notifications.4. Notifications are sent at COMMIT time, not at statement execution time. This is usually what you want but can be surprising if you have long transactions.For the use case described (pushing updates to connected clients), this is dramatically more efficient than polling. We went from ~300 queries/second to essentially zero polling queries.
||
Success metric: Alternative approaches with trade-off analysis average 39 upvotes.
7. Research/Data Contribution
Add relevant research papers, benchmarks, or data that supports or contradicts the article. Link to primary sources. HN values evidence-based discussion.
The canonical reference here is "The Tail at Scale" by Jeff Dean and Luiz André Barroso (Communications of the ACM, 2013). It's one of the most practically useful systems papers ever published.The core insight: for a request that fans out to N servers, the probability of hitting at least one slow server grows as 1-(1-p)^N where p is the per-server probability of being slow. For N=100 and p=0.01, that's 1-(0.99)^100 = 63%. So even if each individual server is "fast" 99% of the time, your overall request hits a straggler most of the time at sufficient fan-out.Their key technique: hedged requests. After the 95th percentile latency passes without a response, send a duplicate request to a different server and use whichever responds first. The extra load is small (you're only hedging 5% of requests) but the tail latency improvement is dramatic.I implemented this in Tarsnap's backup pipeline and saw p99 drop by about 40%. The important subtlety: you must cancel the outstanding request when the hedge returns, otherwise you double your load under sustained high latency (which is exactly when you can least afford it).Another underappreciated technique from the paper: "tied requests" — send the request to two servers simultaneously, but include each server's queue position. The server that dequeues first sends a cancellation to the other. This gives you hedging benefits with almost zero extra work.Paper: https://research.google/pubs/pub40801/
||
Success metric: Comments citing research papers average 44 upvotes.
8. Clarifying Question
Ask a thoughtful question that probes deeper into the technical details. Not basic questions, but ones that reveal edge cases or assumptions. Shows you're thinking critically.
How does this handle the read-modify-write race on the cache?Specifically: (1) Thread A reads value X from cache, (2) Thread B writes value Y to cache, (3) Thread A computes f(X) and writes it back to cache, clobbering Y. This is a textbook lost-update anomaly.The article says "thread-safe" but that term is doing a lot of heavy lifting. Thread-safe individual operations (atomic get, atomic set) don't give you thread-safe compound operations (get-then-set). You need one of:- CAS (compare-and-swap): read the value, compute the update, write it back only if the value hasn't changed. Retry on conflict. Redis has WATCH/MULTI for this. - Single-writer: only one thread/process ever writes to a given cache key. Readers can be concurrent. This is the simplest correct model but limits write throughput. - Version numbers / optimistic locking: attach a monotonic version to each cache entry. The write includes "expected version N" and fails if the current version is N+1.Which model are you using? And does your eviction strategy interact with the consistency model? (i.e., what happens if the key is evicted between the read and the write — do you treat a cache miss as a conflict or silently proceed with potentially stale data?)This matters a lot for correctness guarantees.
||
Success metric: Clarifying questions that reveal edge cases average 31 upvotes.
Community Standards
What gets you downvoted or banned on Hacker News
HN moderators and the community strictly enforce quality standards. These unwritten rules aren't in the official guidelines but violating them results in downvotes, flags, or account penalties.
Generic Praise Without Substance
"Great article!" or "This is exactly right!" adds no value. These comments average -2 to 0 points and often get flagged as noise.
Solution: Explain why with technical reasoning or add novel insights.
Dismissive Criticism
"This is wrong" or "This won't work" without explanation gets flagged. Dismissive comments average -3 points and damage your reputation.
Solution: Explain specifically why with technical reasoning and evidence.
Self-Promotion or Marketing
Mentioning your product or using marketing language gets you flagged and potentially banned. Even subtle self-promotion is detected. HN has zero tolerance.
Solution: Never mention your product in comments. Exception: "Show HN" posts only.
Speculation Presented as Fact
Making claims without evidence or sources gets challenged aggressively. "I heard that..." or "Everyone knows..." gets downvoted.
Solution: Cite sources for claims. Use "I believe" for opinions. HN rewards intellectual honesty.
Personal Attacks or Incivility
Attacking the author or other commenters gets you banned. "You clearly don't understand..." results in immediate moderation.
Solution: Critique ideas, not people. Assume good faith. Stay respectful.
Off-Topic or Meta Discussion
Comments about HN itself, voting patterns, or moderation get flagged. "Why is this being downvoted?" derails discussion and gets removed.
Solution: Stay on topic. Email hn@ycombinator.com for meta concerns.
Explaining Basic Concepts
Explaining what REST APIs are or how Git works gets downvoted. HN audience is highly technical. Condescending explanations are poorly received.
Solution: Assume technical competence. Focus on advanced insights and edge cases.
Formatting Over Substance
Using markdown formatting, emojis, or clever writing without substance gets downvoted. HN is plain text only. Content matters, not presentation.
Solution: Write in plain text. Focus entirely on technical content.
What Happens When You Violate These Rules
HN has three enforcement mechanisms: (1) Community downvotes reduce comment visibility and karma, (2) Users can flag comments, which hides them if enough flags accumulate, (3) Moderators can kill comments, ban accounts, or apply rate limits.
Repeated violations result in account penalties - your comments may be rate-limited (hellbanned) where you can comment but others can't see them. This is often permanent. Recovery: If you get downvoted, don't delete your comment (looks worse). Learn from it. If you get flagged, email hn@ycombinator.com explaining what you'll do differently.
Ready to contribute to Hacker News?
Teract helps you craft technical, thoughtful HN comments that add value and earn upvotes.
Timing determines visibility more than quality. Our analysis of 10,000 comments found that timing accounted for 62% of upvote variance. Comments posted in the first hour averaged 3.8x more upvotes than identical comments posted after 6 hours.
The HN algorithm: New posts appear on /newest. As they get upvotes, they climb to front page. Front page posts are ranked by a formula that decays over time: Score = (Points - 1) / (Age + 2)^1.8. This means posts decay rapidly - a 12-hour-old post needs 4x more upvotes than a 2-hour-old post to maintain the same ranking. Comments on rising posts get maximum visibility.
Optimal Timing Windows
0-45 minutes: Prime opportunity
Best ROI
Posts have 1-30 points, climbing toward front page. This is your optimal window - posts are gaining momentum but comments are sparse. Your comment will be near the top when the post hits front page. Scout phase (0-15 min) offers highest upvotes but carries risk that post won't reach front page. Sweet spot (15-45 min) balances risk and reward.
Average upvotes: 47-52 for quality comments · Success rate: 45% reach front page
45 min - 6 hours: Front page window
Good timing
Posts have 30-200+ points, on front page. High traffic but increasing competition. Early in this window (45min-2hrs) you'll face 5-15 existing comments. Peak front page (2-6hrs) means 30-100+ comments and your comment appears below the fold. Still worth commenting if you have unique technical insight or can reply to top comments for visibility.
Average upvotes: 24-38 for quality comments · Strategy: Reply to top comments
6+ hours: Declining returns
Skip
Posts falling off or off front page entirely. Traffic dropping rapidly with 100+ existing comments. Your comment gets minimal visibility (10-50 views maximum after 12 hours). Not worth the effort unless you're directly answering someone or have truly exceptional insight that warrants a late contribution.
Average upvotes: 3-8 for quality comments · Better use of time: Find newer posts
Time Zone Advantage
HN traffic peaks 9am-5pm Pacific Time (San Francisco). Posts submitted at 8-10am PT get maximum visibility. If you're in Europe or Asia, you can catch rising posts before US wakes up - less competition, same visibility when post hits peak. Our data shows European commenters (commenting 6-8am PT) average 15% more upvotes due to reduced competition. For a broader comparison of developer platforms, see our Reddit vs Hacker News guide.
When is 9am–5pm PT in your timezone?
Times adjust automatically for daylight saving. Post or comment within this window for maximum visibility.
"
"
Online community-building is more like IRL community-building than people realize. Thing is — most people don't wanna do the work.
Alexis Ohanian
Co-founder of Reddit
On this page
Build credibility on Hacker News faster
Teract helps you write thoughtful, technical comments that resonate with the Hacker News community. Add value and build reputation without spending hours crafting responses.
We promise you won't get restricted on any social network. If you do, we'll refund your last payment. No questions asked.
No automation
Teract generates text. You review it. You click post. That's it. From the platform's perspective, you're just a thoughtful person writing good content.
Works across 8 platforms
LinkedIn, X, Reddit, Threads, Medium, BlueSky, Hacker News, and Product Hunt. One tool, zero risk anywhere.
We've run Teract for 2 years with zero bans. It's completely safe because you're in control — Teract generates text, you review it, you post it. No automation, no risk.
