<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Vitalii Petrenko on Medium]]></title>
        <description><![CDATA[Stories by Vitalii Petrenko on Medium]]></description>
        <link>https://medium.com/@vitalii4reva?source=rss-8b5d6ffa844f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KjzNWelKInHtPIEtR2f24Q.jpeg</url>
            <title>Stories by Vitalii Petrenko on Medium</title>
            <link>https://medium.com/@vitalii4reva?source=rss-8b5d6ffa844f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 01:28:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@vitalii4reva/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[40% of AI-Generated Code Has Security Flaws. Your Code Review Won’t Catch Them.]]></title>
            <link>https://javascript.plainenglish.io/40-of-ai-generated-code-has-security-flaws-your-code-review-wont-catch-them-0a02a13848fe?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a02a13848fe</guid>
            <category><![CDATA[software-security]]></category>
            <category><![CDATA[ai-code-review]]></category>
            <category><![CDATA[ai-generated-code]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[code-review]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Sat, 07 Mar 2026 18:42:56 GMT</pubDate>
            <atom:updated>2026-03-07T18:42:56.938Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="40% of AI-generated code has security vulnerabilities — bar chart showing 45% failed security tests, 86% XSS failure rate, and 10x more security issues from AI code" src="https://cdn-images-1.medium.com/max/1024/1*wgAV1g7hrA2zBZndynB2WA.png" /></figure><p>A startup shipped a support ticketing tool built entirely with AI. Within one week, 3,000+ customer tickets were exposed, including credit card numbers. The app had zero authentication. Anyone with the URL could access everything.</p><p>The AI never added auth. Nobody reviewed the code. The app worked perfectly in the demo.</p><p>This actually happened in 2025, <a href="https://karozieminski.substack.com/p/vibecoding-cybersecurity-fix-the-7-code-mistakes-leaving-your-startup-wide-open-and-vulnerable-playbook">documented by security engineer Karo Zieminski</a>. And the uncomfortable part? Nothing about this case was unusual.</p><h3>The numbers keep getting worse</h3><p>I spent a week pulling together every major security study on AI-generated code from 2025–2026. The picture isn’t great.</p><p><a href="https://arxiv.org/abs/2108.09293">Stanford and NYU tested Copilot</a> across 89 code-generation scenarios. 40% of the output contained security vulnerabilities mapped to known CWEs: SQL injection, XSS, buffer overflows, hardcoded credentials. <a href="https://www.veracode.com/resources/analyst-reports/2025-genai-code-security-report/">Veracode ran a broader test</a> across multiple LLMs in Java, Python, C#, and JavaScript, where 45% of generated code failed their security tests. Their XSS number was particularly bad: 86% failure rate against cross-site scripting.</p><p>But the <a href="https://apiiro.com/resources/blog/top-5-security-risks-of-ai-generated-code/">Apiiro data</a> from June 2025 is what really got me. AI-assisted developers in their dataset were producing 3–4x more code than their peers. Sounds great, right? They were also generating 10x more security issues. Over 10,000 new security findings per month, just from AI-generated code.</p><p>More code, more bugs. And the ratio is getting worse.</p><figure><img alt="Bar chart: AI-generated code vulnerability rates — 45% failed security tests (Veracode), 40% vulnerable scenarios (Stanford/NYU), 86% XSS failure rate, 10x more security issues (Apiiro)" src="https://cdn-images-1.medium.com/max/800/1*jyP3zvJrtPoxp-4Tj5St3g.png" /></figure><h3>The confidence problem</h3><p>There’s a Stanford/Boneh study I keep thinking about. Developers using AI assistants wrote less secure code in 4 out of 5 tasks. That alone is bad. But they also reported feeling <em>more confident</em> about their code’s security.</p><figure><img alt="Stanford/Boneh study: developers using AI wrote less secure code in 4 out of 5 tasks but reported feeling more confident about security" src="https://cdn-images-1.medium.com/max/800/1*eyVTzv8oZ8cbgz9rkQNuEQ.png" /></figure><p>I find that genuinely unsettling. The code looks clean, passes tests, runs fine. Meanwhile it’s quietly embedding SQL injection, hardcoded secrets, missing auth checks, and weak cryptography in places you wouldn’t think to look.</p><p>Here’s some of what’s happened in production recently.</p><p><a href="https://www.legitsecurity.com/blog/camoleak-github-copilot-chat-prompt-injection-via-image-proxy">CamoLeak</a> (CVSS 9.6) was a prompt injection attack against GitHub Copilot Chat, discovered by Legit Security. Attackers could hide instructions in PR comments that made Copilot exfiltrate AWS keys from private repos. It affected every Copilot user until Microsoft patched it in August 2025.</p><p>Amazon’s AI coding tool Kiro was involved in a late-2025 incident where a production environment was deleted and recreated, causing a 13-hour outage (per Financial Times sources). Amazon’s account differs — they say the root cause was misconfigured access controls, not the AI itself. But the access control implications remain either way: the tool had the same permissions as the engineer using it, which is the part that bothers me.</p><p>SecurityScorecard found that 1 in 5 “skills” in ClawHub (an AI agent marketplace) were malicious. 135,000 exposed instances. 9 CVEs, 3 with public exploits.</p><p>None of these were freak accidents. This is what happens when generated code ships without review.</p><h3>Vibe coding made it worse</h3><p><a href="https://x.com/karpathy/status/1886192184808149383">Andrej Karpathy coined “vibe coding”</a> in February 2025: describe what you want, let AI generate the code, “forget that the code even exists.”</p><figure><img alt="Andrej Karpathy tweet coining vibe coding — I Accept All always, I don’t read the diffs anymore" src="https://cdn-images-1.medium.com/max/800/1*z20jh7zLOYtraTl1QXskGg.png" /></figure><p>It’s productive. I get it. I’ve done it. But a benchmark study on arXiv tested an agentic coding workflow (SWE-Agent + Claude Sonnet) and found that 61% of solutions were functionally correct. Only 10.5% were secure. Those two numbers are basically uncorrelated, and that should scare you.</p><p>The failure modes are predictable once you start looking. AI tools generate auth guards in React but skip server-side validation, so anyone with browser dev tools can bypass them. Training data is full of tutorials with API keys in source code, so that’s what the model reproduces. <a href="https://www.gitguardian.com/state-of-secrets-sprawl-report-2025">GitGuardian analyzed ~20,000 Copilot-active repos</a> and found a 6.4% secret leakage rate vs 4.6% baseline, about 40% higher. <a href="https://www.kaspersky.com/blog/vibe-coding-2025-risks/54584/">Kaspersky tested vibe-coded apps</a> and found that prompts focused on adding features produced 158 vulnerabilities including 29 critical, while security-focused prompts still produced 38 with 7 critical. Even when you try, you can’t prompt your way to secure code.</p><p>And then there’s phantom dependencies. AI suggests packages that don’t exist on npm or PyPI. Attackers register those names and publish malicious code. Your coding assistant just added malware to your project. I still have trouble believing this is a real attack vector, but it is.</p><p>AppSec Santa summed it up:</p><figure><img alt="he risks are not just that vulnerabilities exist, but that no one with the ability to find or fix them is in the loop — AppSec Santa" src="https://cdn-images-1.medium.com/max/800/1*94K9EIep8pMRAuwmKu4lkQ.png" /></figure><h3>Code review is where you catch this</h3><p>Every vulnerability enters your codebase at a specific moment. For most teams, that’s a pull request.</p><p>The cost difference is brutal. Fixing a vulnerability during code review runs $200–800 in developer time. The same vulnerability in production costs $3,000–10,000+. If it causes a breach, the <a href="https://www.ibm.com/reports/cost-of-a-data-breach">IBM 2025 report</a> puts the global average at $4.44 million. In the US, $10.22 million.</p><figure><img alt="Cost to fix a vulnerability by stage: $200–800 at code review, $3,000–10,000+ in production, $4.44 million average data breach (IBM 2025)" src="https://cdn-images-1.medium.com/max/800/1*g8M_YeEHCHpur3z5OcSqbA.png" /></figure><p>Look at the <a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/">2025 OWASP Top 10</a> and you can see where this is going. Supply Chain Failures jumped to #3. Security Misconfiguration moved from #5 to #2. There’s a new category at #10, Mishandling of Exceptional Conditions, which is basically the empty catch blocks and “fail open” behavior that AI-generated code produces constantly.</p><figure><img alt="OWASP Top 10 2025 changes relevant to AI code: Security Misconfiguration moved from #5 to #2, Supply Chain Failures from #8 to #3, new category Mishandling of Exceptional Conditions at #10" src="https://cdn-images-1.medium.com/max/800/1*yknRvIu35bbfPfSzN9VPaA.png" /></figure><p>Most developers review PRs for logic and readability. Security review takes different knowledge, and with AI now generating 46% of code for active Copilot users (up from 27% in 2022), the volume keeps growing while the security expertise per review stays flat.</p><h3>What I think actually works</h3><p>Automated security scanning on every PR. Not a quarterly SAST pipeline that generates 500 alerts nobody reads. Scanning at the diff level, catching issues when they’re introduced, not six months later.</p><p>The most common AI-introduced vulnerabilities are well-known patterns. SQL injection via string concatenation. XSS through innerHTML or dangerouslySetInnerHTML. Hardcoded API keys. Command injection via exec() with user input. eval() on untrusted data. MD5/SHA1 for passwords. CORS wildcards on authenticated APIs. Disabled SSL verification. Path traversal through unsanitized file paths. Empty catch blocks that silently swallow security errors.</p><p>All of these are detectable with regex rules running locally in your editor. They’re fast, deterministic, and they don’t miss known patterns. Layer an AI security pass on top, specifically prompted for security analysis, and you start catching the logic-level stuff too: authentication bypasses, authorization flaws, SSRF.</p><figure><img alt="Git AutoReview VS Code extension screenshot — security review panel showing vulnerability findings in a pull request" src="https://cdn-images-1.medium.com/max/800/1*UqIVRnuAfqjI7HNanUExaw.png" /></figure><p>I tried a few setups before landing on something that stuck. I built <a href="https://marketplace.visualstudio.com/items?itemName=vitalii4reva.git-autoreview">Git AutoReview</a> around this idea — fifteen regex security rules running locally in VS Code, plus a specialized AI security pass, scanning every PR before merge. Works with GitHub, GitLab, and Bitbucket. Your code goes directly to your AI provider (BYOK). I never see it.</p><p>Free tier is 10 reviews/day. Developer plan is $9.99/month. For comparison, dedicated SAST tools start at $98/month.</p><h3>Where this is going</h3><p>85% of developers use AI coding assistants now. Almost half the new code from active Copilot users is AI-generated. Somewhere between 40% and 62% of that code has security vulnerabilities, depending on which study you trust.</p><p>You can catch these during code review for a few hundred dollars, or find them in production for a few million. Your AI assistant won’t flag the problem. Your current review process probably won’t either.</p><p>I don’t think most teams have processed how much changed when AI started writing half their code. I’m still processing it myself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a02a13848fe" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/40-of-ai-generated-code-has-security-flaws-your-code-review-wont-catch-them-0a02a13848fe">40% of AI-Generated Code Has Security Flaws. Your Code Review Won’t Catch Them.</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Cost of Slow Code Reviews: Data from 8 Million PRs]]></title>
            <link>https://vitalii4reva.medium.com/the-hidden-cost-of-slow-code-reviews-data-from-8-million-prs-9926849f1428?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/9926849f1428</guid>
            <category><![CDATA[code-review]]></category>
            <category><![CDATA[engineering-management]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 20:00:51 GMT</pubDate>
            <atom:updated>2026-02-12T20:00:51.340Z</atom:updated>
            <content:encoded><![CDATA[<p>Your pull request has been open for two days. You’ve context-switched three times, started a new feature, and honestly forgotten half of what you wrote. When your teammate finally reviews it, you’ll spend 20 minutes just re-loading the context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dCNEaEATrG4rI6eZpOJKzw.png" /></figure><p>This isn’t a one-off bad week. This is the default.</p><p>LinearB analyzed <a href="https://linearb.io/resources/engineering-benchmarks">8.1 million pull requests</a> across 4,800 engineering teams and found that half of all PRs sit idle for over 50% of their lifespan. A third of PRs? Idle for nearly 78% of the time between creation and merge. Not being worked on. Not being reviewed. Just… sitting there.</p><p>I spent a few weeks pulling together data from LinearB, Google’s engineering research, DORA, SmartBear, and a handful of academic studies. The short version: slow reviews cost way more than most teams think, and the fixes are boring in the best possible way.</p><h3>The numbers</h3><p>Let’s start with how long things actually take.</p><p>LinearB’s benchmarks break teams into tiers based on PR pickup time (how long until someone starts reviewing):</p><p>📊 [Add image here: PR Pickup Time by Team Tier — Elite &lt;7hrs, Mid-tier 6–50hrs, Lagging 50–137+hrs]</p><ul><li><strong>Elite teams:</strong> pickup under 7 hours, PRs under 219 lines</li><li><strong>Mid-tier teams:</strong> pickup 6–50 hours, PRs 219–395 lines</li><li><strong>Lagging teams:</strong> pickup 50–137+ hours, PRs 395–793+ lines</li></ul><p><em>Source: </em><a href="https://linearb.io/resources/engineering-benchmarks"><em>LinearB Engineering Benchmarks</em></a><em>, 8.1M PRs, 4,800 teams.</em></p><p>Elite teams get a full PR cycle done in under 26 hours. Lagging teams? Their PRs can sit for a week before anyone even looks at them.</p><p>For comparison, Google’s internal data shows an average review turnaround of <a href="https://read.engineerscodex.com/p/how-google-takes-the-pain-out-of">4 hours</a> — small changes get reviewed in about an hour, larger ones in five. Microsoft’s median sits around <a href="https://sback.it/publications/icse2018seip.pdf">24 hours</a>.</p><p>The industry average outside big tech is worse. One study from <a href="https://fullscale.io/blog/code-review-practices-team-productivity/">Full Scale</a> put it at 4.4 days for initial review, with developers losing 5.8 hours per week to review-related bottlenecks.</p><h3>Where the time goes</h3><p>It’s not just the review itself. It’s the waiting <em>between</em> steps:</p><ol><li><strong>Waiting for initial pickup</strong> — the biggest chunk. LinearB’s data shows this is where most idle time lives.</li><li><strong>Back-and-forth comments</strong> — multiple rounds of “can you change this?” followed by another wait cycle.</li><li><strong>Re-review after changes</strong> — the reviewer has to re-load context too.</li><li><strong>Merge conflicts from stale PRs</strong> — the longer a PR sits, the more likely it conflicts with trunk.</li></ol><p>Each step resets the context-switching clock for both the author and the reviewer.</p><h3>The hidden costs</h3><p>The time numbers look bad. The downstream effects are worse.</p><h3>Context switching</h3><p>Gloria Mark’s research at UC Irvine measured how long it takes to regain deep focus after an interruption: <a href="https://trunk.io/learn/context-switching-in-software-engineering">23 minutes and 15 seconds</a>. Not a rough estimate — a measured average across multiple studies.</p><p>For developers, the cost compounds. When you switch from your current feature work to address review comments on code you wrote days ago, you pay the context-switching tax twice: once to leave your current work, once to mentally reload the reviewed code. Research on developer interruptions shows that interrupted tasks take twice as long and produce twice as many errors (Amoroso d’Aragona et al., 2023).</p><p>A <a href="https://conclude.io/blog/context-switching-is-killing-your-productivity/">2022 Harvard Business Review study</a> found that knowledge workers toggle between apps 1,200 times per day, losing about 4 hours per week just reorienting. That’s roughly 5 weeks per year per person, doing nothing productive. Developers get hit harder than most because code demands sustained deep focus.</p><h3>The financial math</h3><p>Here’s a back-of-napkin calculation:</p><ul><li>Average US developer total compensation: ~$130,000/year (<a href="https://www.indeed.com/career/software-engineer/salaries">Indeed</a>, <a href="https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm">BLS</a>, 2025–2026 data)</li><li>Fully loaded cost (benefits, overhead): ~$170,000/year, roughly $82/hour</li><li>Hours lost to review bottlenecks: 5.8/week per developer (<a href="https://fullscale.io/blog/code-review-practices-team-productivity/">Full Scale</a>)</li></ul><blockquote><strong><em>Per developer per year:</em></strong><em> 5.8 hours × 50 weeks × $82 = </em><strong><em>$23,780</em></strong><em><br></em><strong><em>For a team of 10:</em></strong><em> ~$237,800/year. Waiting for code reviews.</em></blockquote><p>That’s not the review itself — reviewing code is valuable work. That’s the <em>idle time</em>. The PRs sitting in a queue. The context switches. The duplicate re-reads.</p><h3>Quality cost</h3><p>Here’s something counterintuitive: slow reviews don’t produce better code. They produce worse code.</p><p>SmartBear’s study of 2,500 PRs found that code review effectiveness peaks at around 200–400 lines and 60 minutes of review time. Beyond that, reviewers start missing things. The detection rate drops from 87% for small PRs (under 100 lines) to just <a href="https://www.propelcode.ai/blog/pr-size-impact-code-review-quality-data-study">28% for PRs over 1,000 lines</a>.</p><p>Detection rates by PR size:</p><ul><li><strong>1–100 lines:</strong> 87% defect detection</li><li><strong>101–300 lines:</strong> 78%</li><li><strong>301–600 lines:</strong> 65%</li><li><strong>601–1,000 lines:</strong> 42%</li><li><strong>1,000+ lines:</strong> 28%</li></ul><p>Code review catches 55–60% of defects on average, outperforming unit testing (25%), function testing (35%), and integration testing (45%). These numbers come from Steve McConnell’s “<a href="https://blog.codinghorror.com/code-reviews-just-do-it/">Code Complete</a>” data, backed by the SmartBear/Cisco study showing up to 90% detection rates for well-sized reviews.</p><p>The IBM Systems Sciences Institute estimated that bugs found in production cost <a href="https://cloudqa.io/how-much-do-software-bugs-cost-2025-report/">roughly 100x more to fix</a> than during design or review. That exact multiplier gets debated — some put it at 10x-30x for modern CI/CD pipelines — but the direction is clear: later is always more expensive. NASA’s Jet Propulsion Laboratory estimated $25,000 in savings per code inspection.</p><p>So when reviews take too long and PRs grow stale and bloated, you lose time <em>and</em> ship more bugs. Double hit.</p><h3>Developer experience</h3><p><a href="https://engineering.fb.com/2022/11/16/culture/meta-code-review-time-improving/">Meta published research</a> on this. They looked at the P75 review time — the slowest quartile — and found it correlated directly with engineer dissatisfaction. Not just “annoyed about reviews” dissatisfaction. Overall job satisfaction tanked for developers whose PRs consistently sat in limbo.</p><ul><li>Developer turnover costs <a href="https://www.betterway.dev/posts/how-to-calculate-turnover-cost-for-tech-teams">100–150% of annual salary</a> to backfill. For a senior dev earning $140K, that’s $170K+ in replacement costs including lost knowledge and ramp-up time.</li><li><a href="https://fullscale.io/blog/code-review-practices-team-productivity/">44% of teams</a> report slow code reviews as their single biggest delivery bottleneck.</li></ul><p>If your best engineers are frustrated and your reviews are slow, those two facts are probably related.</p><h3>Why this happens</h3><p>The problem isn’t that reviewers are lazy or bad at their jobs. It’s structural.</p><p><strong>Reviewers have their own sprint work.</strong> Reviewing someone else’s code means pausing your own tasks. There’s no sprint points for reviews. No OKR for “reviewed 20 PRs this week.” So it becomes the thing that gets pushed to “after lunch” and then “tomorrow morning.”</p><p><strong>PRs are too large.</strong> Google’s engineering practices recommend changes around 200 lines. LinearB’s elite teams average under 219 lines. But many teams ship PRs of 500–1,000+ lines because splitting work into smaller chunks feels like overhead. The irony: larger PRs take disproportionately longer to review <em>and</em> catch fewer bugs.</p><p><strong>Nobody owns the metric.</strong> Teams track deployment frequency. Uptime. Story points. Velocity. Very few teams track PR cycle time or pickup time. If you don’t measure it, you can’t see how bad it is — and you definitely can’t fix it.</p><p><strong>Async doesn’t mean instant.</strong> Distributed teams across time zones can add 8–16 hours of latency per review round just from timezone gaps. Two rounds of review can eat three calendar days even if each round takes 30 minutes of actual work.</p><h3>What high-performing teams do differently</h3><p>The DORA research (now part of Google Cloud) links faster lead times to better outcomes across stability, throughput, and team satisfaction. None of these fixes are surprising. The hard part is actually doing them.</p><h3>1. Keep PRs small</h3><p>If there’s one thing in this article worth acting on, it’s this. LinearB’s data shows elite teams average under 219 lines per PR with a P75 under 98 lines. <a href="https://graphite.com/blog/the-ideal-pr-is-50-lines-long">Graphite’s analysis</a> suggests 50 lines is the ideal size — time-to-review, time-to-merge, and comments-per-line all improve as PRs get smaller.</p><p>Google enforces this culturally. Their Critique tool is built around the assumption that changes will be small and reviewable quickly. It’s why their average turnaround is 4 hours.</p><p>Practical starting point: take your next large PR and split it into two or three smaller ones. See what happens to your cycle time.</p><h3>2. Set pickup time targets</h3><p>You can’t improve what you don’t measure. Start tracking PR pickup time — the gap between “PR opened” and “first review comment.” LinearB’s elite benchmark is under 7 hours. Even targeting “same business day” is a meaningful improvement for most teams.</p><p>Some teams use Slack bots or GitHub Actions to ping reviewers after a threshold. Low-tech but effective.</p><h3>3. Assign reviewers explicitly</h3><p>Unassigned PRs take longer to get reviewed. It’s the bystander effect applied to pull requests: “someone else will get to it.” Assign a specific reviewer at PR creation time. GitHub’s CODEOWNERS file automates this based on file paths.</p><p>Meta’s research on reviewer recommendation systems showed that matching reviewers by file ownership and availability improved the percentage of PRs reviewed within 24 hours.</p><h3>4. Automate what you can</h3><p>This is where tooling helps. Static analysis (SonarQube, ESLint, type checkers) can catch formatting, style, and basic bug patterns before a human even looks at the code. That means the human reviewer spends their time on logic, architecture, and design — the stuff that actually requires a brain.</p><p>AI-assisted code review tools take this further. They can catch potential bugs, suggest improvements, and give you a first-pass review in minutes instead of hours. The data is still early — <a href="https://survey.stackoverflow.co/2025/">46% of developers</a> say they don’t fully trust AI accuracy — but the time savings are real. Studies show AI review can reduce PR turnaround from 2–3 hours to 20–30 minutes for initial feedback.</p><p>The trick is treating AI as a first pass, not the final word. The human reviewer still makes the call. You get faster feedback without giving up judgment.</p><h3>5. Make review time visible</h3><p>Add PR cycle time to your team dashboard alongside deployment frequency and incident count. When the team can see that their average pickup time is 36 hours, the conversation about fixing it starts naturally.</p><h3>The ROI of fixing this</h3><p>Let’s say your team cuts average PR pickup time from 48 hours to 8 hours (lagging to near-elite):</p><p>📊 [Add image here: ROI table — Before/After comparison]</p><ul><li><strong>Avg pickup time:</strong> 48 hrs → 8 hrs (saved 40 hrs)</li><li><strong>Idle time per dev/week:</strong> 5.8 hrs → ~2 hrs (saved 3.8 hrs)</li><li><strong>Annual cost per dev:</strong> $23,780 → $8,200 (saved $15,580)</li><li><strong>Team of 10, annual:</strong> $237,800 → $82,000 (<strong>saved $155,800</strong>)</li></ul><p>That $155K isn’t theoretical. Vercel <a href="https://getdx.com/blog/developer-velocity/">reduced PR cycle times by 43%</a> (from 4.6 to 2.7 hours) just by measuring and optimizing their review pipeline. AT&amp;T’s code inspection program <a href="https://kodus.io/en/the-impact-of-code-review/">cut defects by 90% and raised productivity 14%</a>. CodeScene’s data shows teams with the healthiest codebases ship <a href="https://codescene.com/blog/benchmarking-code-health-refactoring-roi">27–43% faster</a> with 32–50% fewer post-release defects — and review quality is a big part of what keeps code health high.</p><p>And that’s before the stuff that’s harder to put a number on. Features ship faster. Your best developers stick around longer because they’re not grinding through a frustrating process. You get fewer of those 2am production incidents from bugs that should’ve been caught in review.</p><h3>What to do Monday morning</h3><ol><li><strong>Pull your PR metrics.</strong> Most Git platforms have this data. What’s your average pickup time? Cycle time? PR size? If you don’t know, that’s your first problem.</li><li><strong>Set a target.</strong> DORA elite teams have lead times under a day. You don’t need to match Google, but “same business day” for initial review is a reasonable starting line.</li><li><strong>Try one small change.</strong> Split your next big PR into smaller pieces. Or add CODEOWNERS. Or set up a Slack reminder for stale PRs. Pick one, run it for two weeks, check the numbers.</li><li><strong>Make it visible.</strong> Add PR cycle time to your standup or team dashboard. Once the team sees a 48-hour average, the conversation about fixing it happens on its own.</li></ol><p>A caveat: most of the data here comes from large-scale studies of thousands of teams. Your team’s numbers will be different. The specific dollar figures are estimates, not invoices. But the patterns are consistent across every study I looked at — slow reviews cost more than most teams realize, and small process changes compound fast.</p><p><em>Vitalii Petrenko is a software engineer and the creator of </em><a href="https://gitautoreview.com/"><em>Git AutoReview</em></a><em> — an AI code review tool with human-in-the-loop approval for GitHub, GitLab, and Bitbucket. The data and sources in this article are independent of any product.</em></p><p><strong>Sources:</strong> LinearB Engineering Benchmarks (8.1M PRs), Gloria Mark / UC Irvine, Google Engineering Practices, Microsoft Research, SmartBear/Cisco Study, IBM Systems Sciences Institute, Meta Engineering, DORA/Google Cloud, Stack Overflow 2025 Developer Survey. Full source list with links available in the <a href="https://gitautoreview.com/blog/hidden-cost-of-slow-code-reviews">original article</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9926849f1428" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why 85% of Teams Are Implementing Microfrontends Wrong in 2025]]></title>
            <link>https://vitalii4reva.medium.com/why-85-of-teams-are-implementing-microfrontends-wrong-in-2025-d9459f40381f?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9459f40381f</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[micro-frontends]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Thu, 29 May 2025 11:52:03 GMT</pubDate>
            <atom:updated>2025-05-29T11:52:03.409Z</atom:updated>
            <content:encoded><![CDATA[<h3>The harsh reality nobody talks about</h3><p><em>After 15 years building frontend architectures and consulting on 20+ microfrontend projects, I’ve seen the same pattern everywhere: teams expect a silver bullet and get architectural chaos instead.</em></p><p>When I started organizing the Kharkiv Frontend community and speaking at JS conferences, microfrontends felt like the future. Everyone was excited about independent deployments and team autonomy. But here’s what I learned after leading teams through complex migrations and building multi-brand platforms: <strong>microfrontends solve organizational problems, not technical ones.</strong></p><p>And most teams are trying to solve the wrong problems.</p><h3>The numbers don’t lie (but they don’t tell the whole story)</h3><p>Microfrontends usage dropped from 75.4% in 2022 to just 23.6% today. That’s not failure — that’s reality hitting hard.</p><p>The survivors? Mostly large enterprises with genuine needs for architectural independence. Everyone else realized they’d created problems where none existed.</p><p>Module Federation still dominates with 51.8% usage, Single-SPA holds 35.5%. But these stats hide the real pain. Working on a multi-brand sports platform, migrating from legacy architecture to modular systems, I saw what lurks beneath successful statistics:</p><pre>// What demos show you<br>const RemoteComponent = React.lazy(() =&gt; import(&#39;remote-app/Component&#39;));</pre><pre>// What production looks like<br>const RemoteComponent = React.lazy(() =&gt; <br>  import(&#39;remote-app/Component&#39;)<br>    .catch(() =&gt; import(&#39;./FallbackComponent&#39;))<br>    .then(module =&gt; {<br>      // Version conflicts, CORS issues, <br>      // unexpected dependencies...<br>      return handleVersionMismatch(module);<br>    })<br>);Most documentation skips the error handling part. Wonder why?</pre><h3>The 5 deadly sins I see everywhere</h3><h3>1. The Hidden Monolith</h3><p>I once consulted on a project where the team split their frontend into 8 microfrontends but kept a shared Redux store used by all modules. Result? They couldn’t deploy a single module independently.</p><pre>// WRONG: Global state everywhere<br>import { globalStore } from &#39;shared-state&#39;;<br>export const stateA = globalStore.getState().moduleA;</pre><pre>// RIGHT: Local state + events for communication<br>const localState = useLocalStore();<br>const eventBus = useEventBus();<br>eventBus.emit(&#39;user-authenticated&#39;, { userId, token });</pre><p>If you can’t deploy your microfrontends independently, you don’t have microfrontends. You have a distributed monolith with extra steps.</p><h3>2. Framework Madness</h3><p>85% of teams think microfrontends = freedom to use different frameworks. This is the biggest lie in our industry.</p><p>When I allowed teams to choose their frameworks on a React migration project, bundle size grew from 800KB to 2.3MB. Users were downloading React, Vue, and Angular simultaneously.</p><p>Approach Bundle Size Load Time Maintenance Single framework 800KB 2.1s Low Mixed frameworks 2.3MB 6.8s Nightmare My method 950KB 2.4s Manageable</p><p>The performance hit isn’t worth the “flexibility.”</p><h3>3. Dependency Hell 2.0</h3><p>When Team A hasn’t finished upgrading to Angular 15 while everyone else is on the new version, singleton dependencies create chaos.</p><pre>// The problem: different React versions in federated modules<br>shared: {<br>  react: {<br>    singleton: true,  // Only one version allowed!<br>    requiredVersion: &quot;^18.0.0&quot;<br>  }<br>}<br>// remote-app still on React 17 = runtime crash</pre><p>My solution? Centralized dependency management:</p><pre>{<br>  &quot;sharedDependencies&quot;: {<br>    &quot;react&quot;: &quot;18.2.0&quot;,<br>    &quot;react-dom&quot;: &quot;18.2.0&quot;<br>  },<br>  &quot;migrationPath&quot;: {<br>    &quot;react&quot;: {<br>      &quot;from&quot;: &quot;17.x&quot;,<br>      &quot;to&quot;: &quot;18.2.0&quot;,<br>      &quot;deadline&quot;: &quot;2025-03-01&quot;<br>    }<br>  }<br>}</pre><h3>4. CSS Isolation Nightmares</h3><p>After working with qiankun framework (which has serious style isolation issues), I developed my own approach:</p><pre>// Standard Shadow DOM often breaks UI kits<br>:host {<br>  /* styles isolated, but popups don&#39;t work */<br>}<br></pre><pre>// My method: BEM + automatic prefixes<br>.mf-[hash]__component {<br>  &amp;__element {<br>    // PostCSS automatically adds unique prefixes<br>  }<br>}</pre><p>I use a PostCSS plugin that automatically adds prefixes based on git commit hash. Guarantees uniqueness without manual work.</p><h3>5. Performance Degradation</h3><p>Working on a high-frequency trading platform (3 updates per second per widget), I discovered critical optimizations the docs don’t mention:</p><pre>// STANDARD: load all chunks immediately<br>const RemoteApp = React.lazy(() =&gt; import(&#39;remote/App&#39;));</pre><pre>// MY APPROACH: smart loading with prefetch<br>const useSmartImport = (remoteName, componentName) =&gt; {<br>  const [component, setComponent] = useState(null);<br>  <br>  useEffect(() =&gt; {<br>    requestIdleCallback(() =&gt; {<br>      import(`${remoteName}/${componentName}`)<br>        .then(setComponent);<br>    });<br>  }, []);<br>  <br>  return component;<br>};</pre><h3>When microfrontends actually make sense</h3><h3>Success case: My multi-brand platform</h3><p>As team lead on a sports platform with 15+ brands, each with unique requirements, microfrontends were perfect. We reduced new brand deployment time from 2–3 weeks to 3 days.</p><pre>interface BrandConfig {<br>  theme: ThemeConfig;<br>  features: FeatureFlags;<br>  integrations: IntegrationConfig;<br>}</pre><pre>const BrandProvider: React.FC&lt;{ brandId: string }&gt; = ({ brandId }) =&gt; {<br>  const config = useBrandConfig(brandId);<br>  <br>  return (<br>    &lt;MicroFrontendContainer<br>      config={config}<br>      fallback={&lt;BrandLoadingSpinner /&gt;}<br>    /&gt;<br>  );<br>};</pre><h3>Failure case: When NOT to use them</h3><p>A startup with 4 developers wanted to “prepare for future scaling.” After 3 months fighting infrastructure overhead, they went back to a Next.js monolith.</p><p><strong>My rule:</strong> Microfrontends are justified only when you have:</p><ul><li>3+ independent teams (8+ developers each)</li><li>Different business domains with minimal overlap</li><li>Real need for independent releases</li></ul><h3>The monitoring and debugging nightmare</h3><p>After working on that trading application where every millisecond mattered, I built a monitoring system for microfrontends:</p><pre>class MicroFrontendMonitor {<br>  trackComponent(name: string, component: React.ComponentType) {<br>    return class extends React.Component {<br>      componentDidCatch(error: Error, errorInfo: ErrorInfo) {<br>        this.reportError({<br>          microfrontend: name,<br>          error: error.message,<br>          stack: error.stack,<br>          timestamp: Date.now(),<br>          buildHash: process.env.BUILD_HASH<br>        });<br>      }<br>    };<br>  }<br>}</pre><p>In production, the hardest part is reproducing bugs that happen at microfrontend intersections. My approach: comprehensive logging of every inter-module interaction.</p><h3>What’s coming next: My 2025–2026 predictions</h3><p>Based on my experience and trend analysis:</p><h3>1. Server Components + microfrontends</h3><p>React Server Components will change the game. I’m experimenting with this approach now:</p><pre>export default async function RemotePage({ params }) {<br>  const data = await fetchRemoteData(params.id);<br>  <br>  return (<br>    &lt;Suspense fallback={&lt;RemotePageSkeleton /&gt;}&gt;<br>      &lt;RemoteComponent data={data} /&gt;<br>    &lt;/Suspense&gt;<br>  );<br>}</pre><h3>2. Edge-side composition</h3><p>CDN level becomes the new place for microfrontend composition. Testing with Cloudflare Workers.</p><h3>3. AI-assisted architecture</h3><p>Building tools to automatically analyze when to split modules. AI can analyze git history and suggest optimal boundaries.</p><h3>My practical checklist for 2025</h3><p>Before implementing microfrontends, answer YES to ALL:</p><ul><li>[ ] We have 15+ frontend developers in 3+ teams</li><li>[ ] Different business domains with minimal overlap</li><li>[ ] Ready to invest in DevOps infrastructure</li><li>[ ] Have expertise in monitoring systems</li><li>[ ] Conway’s Law works for us (organizational structure supports architecture)</li></ul><p><strong>If even one “NO” — use monorepo with Nx or Lerna.</strong></p><h3>The honest truth about microfrontends</h3><p>After 15+ years in frontend development and working with dozens of projects, my verdict is simple: <strong>microfrontends are a scalpel, not a hammer.</strong></p><p>They work brilliantly in the right context but fail catastrophically when used as a universal solution.</p><p><strong>My advice for 2025:</strong> If you’re not Netflix, Spotify, or Amazon — start with a good monolith on Next.js/Nuxt.js. When you actually face team scaling problems (not code problems!), then consider microfrontends.</p><p>Most teams I consult jump to microfrontends to solve technical problems, then discover they’ve multiplied their organizational challenges instead.</p><p>The question isn’t “Can we build it with microfrontends?”</p><p>The question is “Do our teams actually need architectural independence?”</p><p><strong>What’s your experience?</strong> Have you worked with microfrontends? Did they solve your problems or create new ones? I’m curious to hear real stories from practitioners.</p><p>And if you’re considering microfrontends for your team, feel free to run your situation by me in the comments. I’ve seen enough implementations to spot the warning signs early.</p><p><em>Next article: I’ll dive into specific enterprise success cases and detailed technical solutions that actually work in production. Follow to catch it when it drops.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9459f40381f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hidden Capabilities of Remix.js That Will Transform Your Approach to Markdown Blogs in 2025]]></title>
            <link>https://vitalii4reva.medium.com/hidden-capabilities-of-remix-js-that-will-transform-your-approach-to-markdown-blogs-in-2025-26f960242856?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/26f960242856</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[javascript-frameworks]]></category>
            <category><![CDATA[remix]]></category>
            <category><![CDATA[markdown]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Thu, 15 May 2025 20:44:31 GMT</pubDate>
            <atom:updated>2025-05-15T20:44:31.828Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction: Why Most Developers Get It Wrong</h3><p>Over my 15+ years in web development, I’ve witnessed the rise and fall of dozens of frameworks, approaches, and “revolutionary” technologies. From the early days of jQuery to monolithic Angular applications, from Redux to React Query, from Next.js to the latest Remix.js — I’ve experienced the full cycle of web development evolution.</p><p>My experience developing various projects — from small blogs to large-scale e-commerce platforms — shows that <strong>most developers miss crucial aspects when creating blogs with Remix.js</strong>. They either overcomplicate the architecture or neglect the key advantages of the platform — something I regularly observe when conducting code reviews and consultations for development teams.</p><p>In 2025, Remix.js has finally reached its full potential as a comprehensive framework for creating fast, scalable, and SEO-friendly blogs. But there are entire layers of capabilities that most developers ignore. After working with Next.js, React.js, Vue.js, Angular, and Ember.js (yes, I’ve worked with all of them), I want to share my vision of how to <strong>correctly</strong> build blogs with markdown on Remix.js in 2025.</p><p>Let’s explore why my approach differs from what you’ll find in most tutorials, and how it can completely change your attitude toward development with Remix.</p><h3>Section 1: Remix.js in 2025 — A Truly Different Approach to Blogs</h3><p>If you’re like most developers I’ve worked with, you probably think Remix.js is just “another Next.js competitor.” Throughout my career, I’ve frequently encountered this misconception.</p><p>The reality in 2025: <strong>Remix.js has become a full-fledged framework that fundamentally differs from Next.js in its philosophy</strong>.</p><p>Here’s what developers typically don’t understand:</p><pre>// ❌ Typical incorrect approach (like in Next.js)<br>export async function getStaticProps() {<br>  // Getting data during build time<br>  return { props: { data } }<br>}</pre><pre>// ✅ Correct approach in Remix<br>export async function loader({ request }) {<br>  // Data is loaded on the server for each request<br>  return json(data);<br>}</pre><h3>From My Experience</h3><p>In a culinary web service project, we initially used React and Redux, then migrated to Next.js for better SEO optimization. But this led to unpredictable hydration problems.</p><p>That’s when I turned my attention to Remix and have been a proponent ever since. Here’s what I discovered:</p><ul><li>Remix does <strong>not</strong> generate static pages like Next.js, but uses caching to achieve the same goal</li><li>Remix uses true server-side rendering with data streaming</li><li>Remix isn’t tied to a specific hosting provider (unlike Next.js with Vercel)</li></ul><p>In a recent project, we completely migrated the system to Next.js 14, but I regularly noted that much of the framework’s “magic” complicated debugging. With Remix, you get <strong>less magic, more control</strong>.</p><h3>Comparison Table: Remix.js vs Next.js in 2025</h3><p>Feature Remix.js Next.js My Observations Server Rendering SSR with data streaming SSR + static generation Remix loads pages 30–40% faster on slow connections Routing Nested routes with isolated data loading New App Router system Remix architecture is simpler and more intuitive Edge Deployment Native support for various platforms Focused on Vercel The ability to deploy on any platform is a critical advantage Form Handling Built-in, with progressive enhancement Requires additional libraries Form UX is significantly better in Remix</p><h3>Section 2: Architectural Patterns Nobody Talks About</h3><p>Wait, architecture for a blog? It’s just a few pages with text, right? This is precisely the most common misconception.</p><p>While developing complex applications, I discovered that <strong>hexagonal architecture</strong> is ideal for Remix — it helps separate logic from UI components, and it turns out this same approach works perfectly for blogs.</p><h3>Insider Secret: Hexagonal Architecture in Blogs</h3><p>Most developers don’t know that Remix works best when you clearly separate responsibilities between:</p><ol><li><strong>Remix loaders/actions</strong> — which act as adapters for HTTP requests</li><li><strong>Business logic</strong> — in domain objects and services</li><li><strong>Data layer</strong> — which interacts with storage sources</li></ol><pre>// app/routes/blog.$slug.tsx<br>export async function loader({ params }) {<br>  // Loader as a simple adapter that calls a service<br>  return json(await getBlogPostService(params.slug));<br>}</pre><pre>// app/services/blog.server.ts<br>export async function getBlogPostService(slug) {<br>  // Business logic separated from Remix-specific code<br>  const post = await blogRepository.getBySlug(slug);<br>  return processPostForDisplay(post);<br>}<br>// app/repositories/blog.server.ts<br>export async function getBySlug(slug) {<br>  // Data layer abstracted from business logic<br>  // Can work with file system, DB, CMS, etc.<br>  return // ...<br>}</pre><p>In many projects, I’ve confirmed how important it is to have a clear architecture even for medium-sized projects. This approach allows you to easily change data sources without modifying business logic.</p><h3>Feature Folders vs Route Folders</h3><p>Most Remix examples show a structure based on routes. This is <strong>good for starting but scales poorly</strong>. From experience working on large projects, it’s much more effective to organize code by domains:</p><pre>app/<br>├── routes/<br>│   └── blog.$slug.tsx  # The route itself<br>├── features/<br>│   └── blog/<br>│       ├── components/ # Blog components<br>│       ├── services/   # Services<br>│       └── utils/      # Utilities<br>└── shared/             # Shared code</pre><p>This structure allows us to keep all code related to a specific functionality together, reducing cognitive load and improving maintainability.</p><h3>Section 3: Storing Markdown Content — My Game-Changing Approach</h3><p>Through creating and refactoring dozens of web projects, I’ve developed a very clear understanding: <strong>the choice of content storage method significantly affects scalability, performance, and development ease.</strong></p><p>In 2025, there are four main approaches to storing markdown content in Remix:</p><ol><li>File system</li><li>Databases</li><li>Traditional CMS</li><li>Headless CMS</li></ol><p>Most developers simply use one of them without thinking about the consequences. But my experience shows that a <strong>combined approach</strong> often yields the best results.</p><h3>From My Experience: The Combined Approach</h3><p>When developing a technical blog for a corporate system, we had an interesting challenge: the content needed to be versioned (like in Git) but also needed to support complex queries and filtering.</p><p>Here’s the approach I developed that combined the advantages of all systems:</p><pre>// Architecture pseudocode:<br>// 1. Markdown is stored in a Git repository (for versioning)<br>// 2. Metadata and indexes are stored in PostgreSQL (for fast search)<br>// 3. Headless CMS (Storyblok) serves as an interface for editors<br>// 4. Cached copies of content are stored on Edge for fast delivery<br>export async function loader({ params }) {<br>  // First, check the cache<br>  const cachedPost = await edge.getCache(`post:${params.slug}`);<br>  if (cachedPost) return json(cachedPost);<br>  <br>  // Get metadata from DB<br>  const metadata = await db.getPostMetadata(params.slug);<br>  <br>  // If it&#39;s a new post, get content from Git<br>  const content = await git.getContent(metadata.filepath);<br>  <br>  // Process markdown and cache the result<br>  const processedContent = await mdx.process(content);<br>  await edge.setCache(`post:${params.slug}`, { metadata, content: processedContent });<br>  <br>  return json({ metadata, content: processedContent });<br>}</pre><p>This hybrid approach provides:</p><ul><li>Version control through Git</li><li>Fast search and filtering through PostgreSQL</li><li>User-friendly interface for content managers via Headless CMS</li><li>Lightning-fast loading through Edge caching</li></ul><p>In one project, this approach allowed us to implement a technical blog that loaded in less than 0.5 seconds while supporting full-text search across thousands of technical articles.</p><h3>Comparison Table: Standard Approach vs My Method</h3><p>Aspect Standard Approach My Method Benefits of My Method Versioning Git only or none Git + metadata in DB Complete change history + quick access to metadata Search Limited capabilities Full-text search Instant results even for large blogs For Editors Complex technical process Intuitive interface Non-technical editors can work without problems Speed Moderate Lightning-fast Content delivered via Edge in milliseconds</p><h3>Section 4: MDX — Much More Than Just Markdown</h3><p>While working on an online recipe store project, we needed to display complex recipes with interactive elements. This is where I fully appreciated the power of MDX (Markdown with JSX).</p><p>Most developers use MDX only as “enhanced markdown.” This is a huge mistake. <strong>MDX is a full-fledged component system</strong> that allows you to build extremely effective interfaces.</p><h3>Insider Secret: Custom Components in MDX</h3><p>Here’s how I use MDX in Remix to create truly interactive content:</p><pre>// app/components/BlogComponents.tsx<br>export const RecipeCard = ({ title, time, difficulty, children }) =&gt; (<br>  &lt;div className=&quot;recipe-card&quot;&gt;<br>    &lt;h3&gt;{title}&lt;/h3&gt;<br>    &lt;div className=&quot;recipe-meta&quot;&gt;<br>      &lt;span&gt;⏱️ {time} minutes&lt;/span&gt;<br>      &lt;span&gt;🔥 Difficulty: {difficulty}/5&lt;/span&gt;<br>    &lt;/div&gt;<br>    &lt;div className=&quot;recipe-content&quot;&gt;{children}&lt;/div&gt;<br>  &lt;/div&gt;<br>);</pre><pre>// app/routes/blog._index.tsx<br>import * as React from &#39;react&#39;;<br>import { MDXProvider } from &#39;@mdx-js/react&#39;;<br>import { Outlet } from &#39;@remix-run/react&#39;;<br>import { RecipeCard } from &#39;~/components/BlogComponents&#39;;<br>const components = {<br>  // Replacing standard HTML elements<br>  h1: props =&gt; &lt;h1 className=&quot;title&quot; {...props} /&gt;,<br>  // Adding custom components<br>  RecipeCard,<br>};<br>export default function BlogLayout() {<br>  return (<br>    &lt;MDXProvider components={components}&gt;<br>      &lt;div className=&quot;blog-container&quot;&gt;<br>        &lt;Outlet /&gt;<br>      &lt;/div&gt;<br>    &lt;/MDXProvider&gt;<br>  );<br>}</pre><p>And here’s how it looks in an .mdx file:</p><pre>---<br>title: &quot;The Best Borscht Recipe&quot;<br>date: &quot;2025-05-10&quot;<br>---</pre><pre># {attributes.title}<br>&lt;RecipeCard <br>  title=&quot;Classic Ukrainian Borscht&quot; <br>  time={120} <br>  difficulty={3}<br>&gt;<br>  This is the best borscht recipe you&#39;ll ever try!<br>  <br>  ## Ingredients<br>  - Beetroot<br>  - Meat<br>  - ...<br>&lt;/RecipeCard&gt;</pre><p>Using MDX this way allows you to create much more interactive and rich content than regular markdown.</p><h3>Embedding Interactive Data</h3><p>One of the “hacks” I developed while working on technical blogs is using MDX as a presentation layer for external data:</p><pre>// In your MDX file:<br>export const metadata = {<br>  externalDataKey: &#39;stock-prices-may-2025&#39;<br>};</pre><pre># Stock Market Analysis for May 2025<br>&lt;DynamicChart dataKey={metadata.externalDataKey} /&gt;</pre><p>The DynamicChart component loads data from an API and displays it inside MDX, allowing you to create &quot;live&quot; charts and tables that update automatically.</p><p>I successfully used this approach in many data visualization projects, and it’s perfect for technical blogs on Remix.</p><h3>Section 5: SEO Optimization Everyone Gets Wrong</h3><p>SEO optimization is much more than just adding a few meta tags. In one e-commerce project, I observed how the right SEO strategy increased organic traffic by 40%. My approach to SEO in Remix differs significantly from the standard.</p><h3>Comprehensive Approach to Metadata</h3><p>Most developers limit themselves to basic meta tags. Here’s the <strong>complete set</strong> that should be used for maximum visibility:</p><pre>// app/routes/blog.$slug.tsx<br>export const meta = ({ data }) =&gt; {<br>  if (!data?.post) {<br>    return [<br>      { title: &quot;Article Not Found&quot; },<br>      { description: &quot;Sorry, the article does not exist&quot; }<br>    ];<br>  }</pre><pre>const { post } = data;<br>  <br>  return [<br>    { title: `${post.title} | My Technical Blog` },<br>    { description: post.excerpt },<br>    <br>    // OpenGraph for Facebook, LinkedIn<br>    { property: &quot;og:title&quot;, content: post.title },<br>    { property: &quot;og:description&quot;, content: post.excerpt },<br>    { property: &quot;og:image&quot;, content: post.featuredImage },<br>    { property: &quot;og:type&quot;, content: &quot;article&quot; },<br>    { property: &quot;og:url&quot;, content: `https://myblog.com/blog/${post.slug}` },<br>    { property: &quot;article:published_time&quot;, content: post.publishedAt },<br>    { property: &quot;article:author&quot;, content: &quot;https://myblog.com/about&quot; },<br>    <br>    // Twitter<br>    { name: &quot;twitter:card&quot;, content: &quot;summary_large_image&quot; },<br>    { name: &quot;twitter:title&quot;, content: post.title },<br>    { name: &quot;twitter:description&quot;, content: post.excerpt },<br>    { name: &quot;twitter:image&quot;, content: post.featuredImage },<br>    <br>    // Canonical URL (critical for duplicate content)<br>    { tagName: &quot;link&quot;, rel: &quot;canonical&quot;, href: `https://myblog.com/blog/${post.slug}` },<br>    <br>    // Additional metadata for SEO<br>    { name: &quot;keywords&quot;, content: post.keywords.join(&quot;, &quot;) },<br>    { name: &quot;author&quot;, content: &quot;Vitalii Petrenko&quot; },<br>    <br>    // JSON-LD Schema for structured data<br>    {<br>      tagName: &quot;script&quot;,<br>      &quot;type&quot;: &quot;application/ld+json&quot;,<br>      children: JSON.stringify({<br>        &quot;@context&quot;: &quot;https://schema.org&quot;,<br>        &quot;@type&quot;: &quot;BlogPosting&quot;,<br>        &quot;headline&quot;: post.title,<br>        &quot;image&quot;: post.featuredImage,<br>        &quot;datePublished&quot;: post.publishedAt,<br>        &quot;dateModified&quot;: post.updatedAt,<br>        &quot;author&quot;: {<br>          &quot;@type&quot;: &quot;Person&quot;,<br>          &quot;name&quot;: &quot;Vitalii Petrenko&quot;<br>        }<br>      })<br>    }<br>  ];<br>};</pre><h3>Dynamic Sitemap and robots.txt</h3><p>The standard approach involves generating static sitemap.xml and robots.txt files. But for blogs with constantly changing content, I developed a dynamic approach:</p><pre>// app/routes/sitemap[.]xml.tsx<br>import { LoaderFunction } from &quot;remix&quot;;</pre><pre>export const loader: LoaderFunction = async ({ request }) =&gt; {<br>  // Get all publications from DB or API<br>  const posts = await getBlogPosts();<br>  <br>  // Form XML<br>  const sitemap = `<br>    &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>    &lt;urlset xmlns=&quot;http://www.sitemaps.org/schemas/sitemap/0.9&quot;&gt;<br>      &lt;url&gt;<br>        &lt;loc&gt;https://myblog.com&lt;/loc&gt;<br>        &lt;lastmod&gt;${new Date().toISOString()}&lt;/lastmod&gt;<br>        &lt;priority&gt;1.0&lt;/priority&gt;<br>      &lt;/url&gt;<br>      <br>      ${posts.map(post =&gt; `<br>        &lt;url&gt;<br>          &lt;loc&gt;https://myblog.com/blog/${post.slug}&lt;/loc&gt;<br>          &lt;lastmod&gt;${new Date(post.updatedAt).toISOString()}&lt;/lastmod&gt;<br>          &lt;priority&gt;0.8&lt;/priority&gt;<br>        &lt;/url&gt;<br>      `).join(&#39;&#39;)}<br>      <br>      &lt;!-- Other static pages --&gt;<br>    &lt;/urlset&gt;<br>  `;<br>  <br>  return new Response(sitemap, {<br>    status: 200,<br>    headers: {<br>      &quot;Content-Type&quot;: &quot;application/xml&quot;,<br>      &quot;Cache-Control&quot;: &quot;public, max-age=3600&quot;<br>    }<br>  });<br>};</pre><p>This approach ensures search engines always have up-to-date information about your site structure.</p><h3>From My Experience</h3><p>In one blog project, we faced the problem of duplicate content due to different paths to the same resource. For example, an article was available at:</p><ul><li>/recipes/pasta-carbonara</li><li>/chef/gordon-ramsay/recipes/pasta-carbonara</li><li>/category/italian/pasta-carbonara</li></ul><p>This negatively affected SEO until I implemented a canonical URL system and proper &lt;link rel=&quot;canonical&quot;&gt; settings. This increased our organic conversions by 35%.</p><h3>Section 6: Performance, Caching, and Deployment That Actually Work</h3><p>Theoretical knowledge always differs from practical application. In one trading application project, I faced strict performance requirements: the app had to support data updates 3 times per second for each widget while using minimal resources.</p><p>I transferred these lessons to blogs on Remix.js.</p><h3>Three-Level Caching Strategy</h3><p>Most developers stop at one level of caching, but for truly fast applications, you need to use all three:</p><pre>// 1. HTTP caching via headers<br>export function headers() {<br>  return {<br>    &quot;Cache-Control&quot;: &quot;public, max-age=300, s-maxage=3600, stale-while-revalidate=86400&quot;,<br>  };<br>}</pre><pre>// 2. In-memory caching on the server<br>let cache = new Map();<br>export async function loader({ params, request }) {<br>  const slug = params.slug;<br>  const cacheKey = `post:${slug}`;<br>  <br>  // Check cache<br>  if (cache.has(cacheKey)) {<br>    return json(cache.get(cacheKey));<br>  }<br>  <br>  // Get data<br>  const post = await getPost(slug);<br>  <br>  // Store in cache<br>  cache.set(cacheKey, post);<br>  <br>  return json(post);<br>}<br>// 3. Client-side caching using useFetcher and useTransition<br>function BlogPost() {<br>  const fetcher = useFetcher();<br>  <br>  // Prefetch related posts on hover<br>  function handleMouseEnter(slug) {<br>    fetcher.load(`/blog/${slug}`);<br>  }<br>  <br>  // Rest of the component<br>}</pre><h3>Profiling Server-side Code</h3><p>The most common mistake is optimizing the wrong parts of the code. In a large project, I developed an approach to profiling Remix applications using the Server Timing API:</p><pre>export async function loader({ request }) {<br>  const start = Date.now();<br>  <br>  // Get data<br>  const posts = await getPosts();<br>  const dbTime = Date.now() - start;<br>  <br>  // Process markdown<br>  const startProcessing = Date.now();<br>  const processedPosts = await Promise.all(posts.map(processMarkdown));<br>  const processingTime = Date.now() - startProcessing;<br>  <br>  return json(processedPosts, {<br>    headers: {<br>      &quot;Server-Timing&quot;: `db;dur=${dbTime}, markdown;dur=${processingTime}`<br>    }<br>  });<br>}</pre><p>This allows you to identify “bottlenecks” and optimize specifically the parts that actually need attention.</p><h3>Deployment on Different Platforms</h3><p>One of the key secrets of Remix I discovered is the ability to optimize deployment for a specific platform.</p><p>For small blogs, I recommend Cloudflare Pages:</p><pre># Example Remix setup for Cloudflare<br>npx create-remix@latest --template remix-run/remix/templates/cloudflare</pre><p>For more complex applications with heavy operations — AWS:</p><pre>// remix.config.js for AWS<br>/** @type {import(&#39;@remix-run/dev&#39;).AppConfig} */<br>module.exports = {<br>  serverBuildTarget: &quot;arc&quot;,<br>  server: &quot;./server.js&quot;,<br>  ignoredRouteFiles: [&quot;**/.*&quot;],<br>  appDirectory: &quot;app&quot;,<br>  assetsBuildDirectory: &quot;public/build&quot;,<br>  serverBuildPath: &quot;server/index.js&quot;,<br>  publicPath: &quot;/build/&quot;,<br>  future: {<br>    unstable_cssModules: true,<br>    unstable_cssSideEffectImports: true,<br>    v2_errorBoundary: true,<br>    v2_meta: true,<br>    v2_routeConvention: true,<br>    v2_normalizeFormMethod: true,<br>  },<br>};</pre><p>In a recent project, we deployed a Remix application on AWS using Lambda@Edge for routing, S3 for storing static files, and DynamoDB for data — this provided excellent performance under significant loads.</p><h3>Section 7: The Future — AI Integration and New Remix.js Features</h3><p>Throughout my career, I’ve always tried to stay a step ahead. In a recent AI-powered content generation project, I implemented advanced approaches to integrating AI with modern frameworks.</p><p>In 2025, I see the future of Remix.js blogs in the following directions:</p><h3>AI Integration to Enhance Your Blog</h3><p>Here’s my approach to integrating the OpenAI API with Remix for streaming responses:</p><pre>// app/routes/api.ai-assistant.tsx<br>import { eventStream } from &#39;remix-utils&#39;;<br>import { OpenAI } from &#39;openai&#39;;</pre><pre>export async function loader({ request }) {<br>  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });<br>  const url = new URL(request.url);<br>  const prompt = url.searchParams.get(&quot;prompt&quot;);<br>  <br>  // Initialize streaming for the client<br>  return eventStream(request.signal, function setup(send) {<br>    // Create stream from OpenAI<br>    const stream = openai.chat.completions.create({<br>      model: &quot;gpt-3.5-turbo&quot;,<br>      messages: [{ role: &quot;user&quot;, content: prompt }],<br>      stream: true<br>    });<br>    <br>    // Send each part of the response to the client<br>    (async () =&gt; {<br>      for await (const part of stream) {<br>        send({ data: part.choices[0]?.delta?.content || &quot;&quot; });<br>      }<br>    })();<br>  });<br>}</pre><p>This code uses eventStream from remix-utils to stream responses from OpenAI directly to the user, providing an interactive experience without blocking the interface.</p><h3>New Remix Features That Will Change Blog Development</h3><p>In May 2025, Remix introduced support for direct serialization of complex types in turbo-stream 2.4.1. This opens new possibilities for data streaming in blogs:</p><pre>// Before turbo-stream 2.4.1 <br>const data = {<br>  date: date.toISOString(), // Converting Date to string<br>  map: Object.fromEntries(map) // Converting Map to a regular object<br>};<br><br>// With turbo-stream 2.4.1<br>const data = {<br>  date, // Directly passing Date object<br>  map   // Directly passing Map<br>};</pre><h3>My Prediction for Remix.js Development in 2025–2026</h3><p>Based on my experience working with various JavaScript frameworks over the past 15 years, I predict the following trends:</p><ol><li><strong>Deeper integration with Edge computing</strong> — Remix will become the standard for leveraging distributed computing advantages</li><li><strong>Streaming rendering for all components</strong> — current support for data streaming will extend to all rendering</li><li><strong>React Server Components</strong> — although Remix already uses a server model, I expect full RSC support</li><li><strong>Adaptive rendering</strong> — automatic determination of the optimal rendering strategy depending on the client device</li><li><strong>Native multilingual support</strong> — simplified localization without additional libraries</li></ol><p>In many projects, I’ve already started implementing some of these approaches using experimental Remix features, and the results have been impressive.</p><h3>Conclusion: My Strategic View on Developing Blogs with Remix.js</h3><p>Over 15+ years working with web technologies, I’ve seen trendy frameworks, libraries, and approaches come and go. But Remix.js, with its “use the platform” philosophy and server orientation, seems to have found the sweet spot between productivity, flexibility, and development convenience.</p><p>Based on my years of experience with various frameworks and projects, I’ve identified key principles that will make your Remix.js blog truly outstanding:</p><ol><li><strong>Use hexagonal architecture</strong> for clear separation of responsibilities</li><li><strong>Combine different storage approaches</strong> for optimal balance between versioning, speed, and convenience</li><li><strong>Unlock the full potential of MDX</strong> through custom components and dynamic data</li><li><strong>Implement multi-level caching</strong> for maximum performance</li><li><strong>Optimize SEO using a complete set of metadata</strong> and JSON-LD schemas</li></ol><p>The most important thing I’ve understood over all these years working with different technologies — there is no universal solution. Each project is unique, and true expertise lies not in following “best practices,” but in understanding when and how to adapt them to specific needs.</p><p>And don’t forget to subscribe to my blog, where I regularly publish technical articles about modern web development.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=26f960242856" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Web Architecture of the Future: Why Remix.js Outperforms Next.js in 2025]]></title>
            <link>https://vitalii4reva.medium.com/the-web-architecture-of-the-future-why-remix-js-outperforms-next-js-in-2025-0bd949198857?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/0bd949198857</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[javascript-frameworks]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Mon, 12 May 2025 19:26:26 GMT</pubDate>
            <atom:updated>2025-05-12T19:26:26.072Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Rendering Revolution and a Return to Web Development Fundamentals</h3><p><em>In a world where web framework architectures are becoming increasingly complex, Remix.js offers a paradoxical solution — returning to web technology fundamentals while leveraging cutting-edge tools. Much like how modern architecture often finds inspiration in classical forms, Remix reimagines fundamental HTTP approaches, making them relevant again for contemporary challenges.</em></p><p>In 2025, the battle of React frameworks for full-stack web development has reached a new level. While Next.js remains a popular choice, statistical data, benchmarks, and successful migration cases demonstrate that Remix.js offers a technically superior solution. This analysis presents an objective comparison based on documented facts, performance metrics, and the philosophical principles underlying both frameworks.</p><h3>1. Evolution of Paradigms: Two Paths in Web Development</h3><p>Next.js, launched in 2016 by Vercel (formerly Zeit), has evolved as a comprehensive solution for React applications. It offers a variety of rendering options — SSR, SSG, ISR, CSR — attempting to satisfy every possible use case. But, as often happens with universal tools, this flexibility comes at a price — growing complexity.</p><pre>// Next.js: different rendering strategies for different pages<br>// pages/static.js (SSG)<br>export async function getStaticProps() {<br>  return { props: { data } };<br>}</pre><pre>// pages/dynamic.js (SSR)<br>export async function getServerSideProps() {<br>  return { props: { data } };<br>}</pre><pre>// pages/incremental.js (ISR)<br>export async function getStaticProps() {<br>  return { props: { data }, revalidate: 60 };<br>}</pre><p>In contrast, Remix, created by the authors of React Router, presents a single, consistent model focused on server-side rendering and progressive enhancement — a philosophy according to which applications should work even without JavaScript, gradually expanding functionality when client capabilities are available.</p><pre>// Remix: unified approach to data loading<br>export async function loader({ params }) {<br>  return json(await db.getProduct(params.id));<br>}</pre><pre>export default function Product() {<br>  const product = useLoaderData();<br>  return &lt;div&gt;{/* product rendering */}&lt;/div&gt;;<br>}</pre><p><em>Working with both frameworks, I’ve noticed that Next.js often forces me to invent different approaches for similar problems. With Remix, I follow one pattern and just move forward — as a developer, this allows me to focus on business logic rather than framework peculiarities.</em></p><h3>2. Architectural Advantage: Performance Metrics and Technical Benchmarks</h3><p>Comparative studies from 2024–2025 show an undeniable advantage of Remix in key performance metrics:</p><ol><li><strong>Faster build time</strong>: Remix uses esbuild/Vite, providing almost instantaneous compilation compared to Webpack in Next.js.</li><li><strong>More efficient data delivery</strong>: Instead of Next.js’s custom mechanisms, Remix uses the standard Fetch API, making SSR faster and more flexible.</li><li><strong>Less client-side JavaScript</strong>: Next.js encourages the use of client-side JS for handling dynamic content, while Remix minimizes this dependency.</li><li><strong>Optimized rendering in slow networks</strong>: Remix is designed to ensure a fast user experience even with limited bandwidth.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KZll_a8lTP32TEQhVsFcIw.png" /></figure><p>Josef Erben’s project migration case study from Next.js to Remix clearly demonstrates these advantages:</p><ul><li>Reduction in JavaScript dependencies from 86 to 39</li><li>Decrease in bundle size from 133KB to 28KB</li><li>Significant acceleration in page interactivity</li></ul><p><em>When I first saw these figures, I was skeptical. But after implementing a similar migration in my own project, the results were impressive. The application became noticeably faster not only objectively by metrics but also subjectively for users — when a page feels fast, it creates a subconscious impression of a quality product.</em></p><h3>3. Loader-Action Pattern: A Revolution in Data Handling</h3><p>Remix.js’s data model, centered around the concepts of loader and action, represents a fundamental rethinking of data handling in web applications.</p><pre>// Form processing in Remix<br>export async function action({ request }) {<br>  const formData = await request.formData();<br>  const username = formData.get(&quot;username&quot;);<br>  const password = formData.get(&quot;password&quot;);<br>  <br>  // Validation and processing<br>  // ...<br>  <br>  return redirect(&quot;/dashboard&quot;);<br>}</pre><pre>export default function Login() {<br>  return (<br>    &lt;Form method=&quot;post&quot;&gt;<br>      &lt;input name=&quot;username&quot; /&gt;<br>      &lt;input name=&quot;password&quot; type=&quot;password&quot; /&gt;<br>      &lt;button type=&quot;submit&quot;&gt;Login&lt;/button&gt;<br>    &lt;/Form&gt;<br>  );<br>}</pre><p>While Next.js requires separate API routes, React Query or SWR for managing requests, and specialized form libraries for client validation, Remix integrates these concepts into a single, coherent model that works regardless of JavaScript availability in the browser.</p><p>This allows:</p><ol><li>Significantly reduce the amount of client code</li><li>Simplify error handling and validation</li><li>Ensure the application works even with JavaScript disabled</li></ol><blockquote>“When I used Remix, all screens came down to implementing 3 things following a pattern: retrieving data for use on the screen, sending data through a form from the screen, and handling POST actions and storing data. This creates a very simple pattern that’s easy to manage” — anonymous developer from Reddit.</blockquote><h3>4. Nested Routing and Code Organization</h3><p>Next.js’s routing system is based on file structure, where each file in the directory corresponds to a route. While this is intuitively understandable for simple applications, this model has limitations when working with complex interfaces.</p><p>Remix offers nested routing, where components can be organized hierarchically, accurately reflecting the URL structure:</p><pre>// app/routes/dashboard.jsx (parent route)<br>import { Outlet } from &quot;@remix-run/react&quot;;</pre><pre>export default function Dashboard() {<br>  return (<br>    &lt;div&gt;<br>      &lt;SideNav /&gt;<br>      &lt;main&gt;<br>        &lt;Outlet /&gt;<br>      &lt;/main&gt;<br>    &lt;/div&gt;<br>  );<br>}</pre><pre>// app/routes/dashboard.reports.jsx (nested route)<br>export default function Reports() {<br>  return &lt;div&gt;Reports&lt;/div&gt;;<br>}</pre><p>This system provides:</p><ol><li>Natural composition of UI components</li><li>Reduction in layout code duplication</li><li>More meaningful organization of the codebase</li><li>Parallel data loading for nested components</li></ol><p><em>Working on large corporate systems, I noticed that Remix’s nested routing naturally reflects the mental model of business domains. For example, a customer management module with subsections for profiles, orders, and billing is easily modeled through nested routes, making the code more intuitive even for new team members.</em></p><h3>5. Web Standards Philosophy vs. Vendor Lock-in</h3><p>At a fundamental level, the difference between Next.js and Remix lies in their philosophical approaches to web development.</p><h4><strong>Next.js: Vendor-Driven Ecosystem</strong></h4><p>Next.js is tightly integrated with the Vercel platform, which develops and maintains the framework. While this allows for powerful integrated solutions, it also creates issues:</p><ol><li>Dependency on a single vendor (vendor lock-in)</li><li>Optimizations oriented toward a specific platform</li><li>Potential conflicts of interest in framework development</li></ol><h4>Remix: Focus on Web Standards</h4><p>Remix builds its approach on using and extending web standards:</p><ol><li>Using the native Fetch API instead of custom abstractions</li><li>Working with native HTML forms with progressive enhancement</li><li>Caching strategy through HTTP headers instead of a proprietary system</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-Vxm2lwDaLZw7SbQShnySQ.png" /></figure><p><em>When you bet on Remix, you’re betting on web standards and the Vite ecosystem. With Next.js, you’re essentially betting on Vercel. This isn’t just a technical choice, but a strategic decision about the future flexibility of your application.</em></p><h3>6. Progressive Enhancement: Returning to Web Development Fundamentals</h3><p>One of Remix’s most significant advantages is its commitment to progressive enhancement. In a world where applications often become unusable with the slightest JavaScript issues, Remix returns to web technology basics.</p><p>Progressive enhancement features in Remix:</p><ol><li><strong>Forms work without JavaScript</strong>: Traditional HTML form submission provides basic functionality.</li><li><strong>Gradual addition of interactivity</strong>: JavaScript is used to enhance experience, not as a requirement.</li><li><strong>HTML streaming</strong>: The server can progressively send content, improving the perception of loading time.</li><li><strong>Elegant degradation</strong>: With network or JavaScript problems, the application remains functional in basic mode.</li></ol><p><em>After developing several large applications with Remix, I was impressed by how the principle of progressive enhancement transformed our attitude toward reliability. With unstable connections, the application continued to function, albeit with less interactivity. For users in regions with limited internet access, this was a real breakthrough in accessibility.</em></p><h3>Conclusion: Technological Choice as a Reflection of Values</h3><p>The choice between Next.js and Remix.js is not just a technical decision, but a reflection of broader values and priorities in software development. Historically, the evolution of web technologies has moved cyclically: from simple static pages to complex client applications, and now to hybrid solutions that combine the best of both worlds.</p><p>Remix represents a new wave that returns to web development fundamentals but uses the most modern tools and methodologies. This approach reflects a broader trend in the technology industry — finding a balance between complexity and accessibility, between capabilities and limitations, between innovation and stability.</p><p>In 2025, as web applications become increasingly critical infrastructure for business and society, choosing a framework focused on performance, reliability, and accessibility becomes a strategic decision. Remix.js offers this combination, providing technical advantage today and laying foundations for sustainable development in the future.</p><p><em>As a software architect with experience in both ecosystems, I see that Remix doesn’t just offer technically better solutions — it represents a more sustainable model of web development. In an era when digital technologies should be accessible to everyone, regardless of device or connection quality, the Remix approach seems not just a technical choice, but an ethical one.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0bd949198857" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Securing Environment Variables in Remix: A Practical Guide]]></title>
            <link>https://vitalii4reva.medium.com/securing-environment-variables-in-remix-a-practical-guide-4a51297d3487?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a51297d3487</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[remixjs]]></category>
            <category><![CDATA[server-side-rendering]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Thu, 27 Mar 2025 16:06:08 GMT</pubDate>
            <atom:updated>2025-03-27T16:06:08.783Z</atom:updated>
            <content:encoded><![CDATA[<p>Hey there! Today, I want to share how I solved a common yet serious security issue in Remix.js apps: exposing sensitive environment variables in the client-side HTML source code. While Remix is an awesome framework, some challenges require custom solutions — and environment variables security is definitely one of them.</p><h3>The Problem: When Your API Keys Are Exposed to Everyone</h3><p>Let me paint you a picture of the issue I faced:</p><pre>// Original code in entry.server.tsx<br>const envScript = `window.__ENV__ = ${JSON.stringify(env)};`;</pre><pre>// Which output this directly into HTML source:<br>&lt;script&gt;window.__ENV__ = {&quot;API_KEY&quot;:&quot;your-secret-key-here&quot;,&quot;PRIVATE_URL&quot;:&quot;https://internal-api.company.com&quot;};&lt;/script&gt;</pre><p>Yikes! Anyone viewing our page source could see ALL my environment variables. Sure, I wasn’t putting AWS keys there, but even seemingly harmless variables can create security vectors when exposed.</p><p>This approach had several problems:</p><ul><li><strong>Security risk</strong>: Variables visible in plain text</li><li><strong>No filtering mechanism</strong>: All variables or none</li><li><strong>Anti-pattern</strong>: Global window object pollution</li></ul><h3>How Other Frameworks Tackle This</h3><p>Before showing my solution, let’s see how the “big players” handle this issue:</p><h3>Next.js Approach: Convention-Based Prefixing</h3><p>Next.js uses a build-time approach with clear conventions:</p><pre>// Only variables with NEXT_PUBLIC_ prefix are included in the client bundle<br>// Everything else stays server-side<br>const publicKey = process.env.NEXT_PUBLIC_API_KEY; // Available client-side<br>const secretKey = process.env.SECRET_API_KEY;      // Server-side only</pre><p><strong>Pros</strong>: Simple convention, clear separation<br> <strong>Cons</strong>: Requires rebuild when variables change, hardcoded during build</p><h3>Nuxt.js Approach: Runtime Configuration Objects</h3><p>Nuxt uses runtime configs:</p><pre>// nuxt.config.js<br>export default {<br>  publicRuntimeConfig: {<br>    apiBase: process.env.API_BASE || &#39;https://api.example.com&#39;<br>  },<br>  privateRuntimeConfig: {<br>    apiSecret: process.env.API_SECRET<br>  }<br>}</pre><p>Access in components:</p><pre>const config = useRuntimeConfig();<br>console.log(config.public.apiBase); // Public var, safe for client</pre><p><strong>Pros</strong>: Clear separation, runtime access<br> <strong>Cons</strong>: Custom implementation, not standard JS</p><h3>My Solution: Best of All Worlds</h3><p>I wanted a solution that:</p><ul><li>Doesn’t expose variables in HTML source</li><li>Works with Remix’s loader pattern</li><li>Has early access for critical variables</li><li>Is type-safe and optimized</li></ul><p>Here’s what I built, step by step:</p><h3>1. Remove Direct HTML Injection</h3><p>First, I removed the direct window.<strong>ENV</strong> injection from my server-side code:</p><pre>// BEFORE (insecure)<br>const envScript = `window.__ENV__ = ${JSON.stringify(env)}; window.__REACT_QUERY_STATE__ = ${JSON.stringify(<br>  safeDehydrate(queryClient)<br>)};`;</pre><pre>// AFTER (secure)<br>// ✨ Notice how I completely removed the environment variables from the script<br>const queryStateScript = `window.__REACT_QUERY_STATE__ = ${JSON.stringify(<br>  safeDehydrate(queryClient)<br>)};`;</pre><h3>2. Leverage Remix Loaders for Environment Variables</h3><p>Next, I use Remix’s built-in loaders to pass only the public variables to the client:</p><pre>// root.tsx loader<br>export const loader: LoaderFunction = async ({ request }) =&gt; {<br>  // Other loader logic...<br>  <br>  return {<br>    ENV: {<br>      // ✨ Only include variables with a specific prefix or pattern<br>      REMIX_PUBLIC_API_URL: process.env.REMIX_PUBLIC_API_URL,<br>      REMIX_API_VERSION: process.env.REMIX_API_VERSION,<br>      // Only public variables!<br>    },<br>    // Other data...<br>  };<br>};</pre><h3>3. Initialize Environment in React Component</h3><p>I needed to set up the environment vars when the app initializes:</p><pre>// App component in root.tsx<br>export default function App() {<br>  // Other hooks and setup...<br>  <br>  // ✨ Initialize environment variables from loader data<br>  useInitializeEnv();<br>  <br>  // Rest of the component...<br>}</pre><h3>4. Create a Powerful Hook System</h3><p>Now I built a robust hooks system to handle my environment variables:</p><pre>// hooks/useEnv.ts<br>export function useInitializeEnv() {<br>  const loaderData = useLoaderData&lt;{ ENV?: EnvVariables }&gt;();<br>  const setEnv = useSetAtom(envAtom);<br>  // Other atom setters...</pre><pre>// ✨ Use isomorphic layout effect to update as early as possible<br>  useIsomorphicLayoutEffect(() =&gt; {<br>    if (loaderData?.ENV) {<br>      // Update atoms with environment data<br>      setEnv(loaderData.ENV);<br>      // Update individual atoms and cache<br>      // ...<br>    }<br>  }, [loaderData?.ENV]);<br>}<br>// Specialized hooks for better performance<br>export function useApiVersion() {<br>  return useAtomValue(apiVersionAtom);<br>}<br>export function useCdnUrl() {<br>  return useAtomValue(cdnUrlAtom);<br>}</pre><h4>Understanding useIsomorphicLayoutEffect</h4><p>What’s useIsomorphicLayoutEffect? It&#39;s a custom hook that ensures my environment variables are set as early as possible in the component lifecycle, but without causing hydration mismatch errors:</p><pre>// utils/hooks.ts<br>// This hook runs synchronously after all DOM mutations<br>// It makes sure my env vars are set before first render<br>export const useIsomorphicLayoutEffect = <br>  typeof window !== &#39;undefined&#39; ? React.useLayoutEffect : React.useEffect;</pre><p>This is crucial because:</p><ol><li>useLayoutEffect runs synchronously after DOM mutations but before paint, ideal for reading/updating DOM</li><li>But useLayoutEffect causes warnings during server-side rendering</li><li>useIsomorphicLayoutEffect uses useLayoutEffect on client but safer useEffect on server</li><li>This ensures my environment variables are available immediately, even before the first visible render!</li></ol><h3>5. Handle Early Access to Variables</h3><p>The tricky part was handling variables needed before React initialization. My solution: fallback values in a centralized config:</p><pre>// config/fallbacks.ts<br>export const ENV_FALLBACKS = {<br>  // ✨ Default values for critical variables<br>  REMIX_PUBLIC_API_URL: &#39;https://public-gateway.example.com&#39;,<br>  REMIX_API_VERSION: &#39;v1&#39;,<br>  // Other critical variables with fallbacks<br>};</pre><pre>export const getFallbackValue = (key: string): string | undefined =&gt; {<br>  return ENV_FALLBACKS[key as keyof typeof ENV_FALLBACKS];<br>};</pre><p>Then use these fallbacks in my environment value getter:</p><pre>// utils/environment.ts<br>const getEnvValueImpl = (key: keyof EnvVariables): string | undefined =&gt; {<br>  // ✨ Multi-layer resolution strategy with caching<br>  <br>  // Check cache first<br>  if (cachedValues[key] !== undefined) {<br>    return cachedValues[key] as string | undefined;<br>  }</pre><pre>// Server: use process.env<br>  if (typeof window === &#39;undefined&#39;) {<br>    const value = process.env[key];<br>    cachedValues[key] = value;<br>    return value;<br>  }<br>  // Client: check atoms cache<br>  if (cachedEnv &amp;&amp; cachedEnv[key] !== undefined) {<br>    cachedValues[key] = cachedEnv[key];<br>    return cachedEnv[key];<br>  }<br>  <br>  // For early access before React initialization<br>  const fallbackValue = getFallbackValue(key);<br>  if (fallbackValue) {<br>    cachedValues[key] = fallbackValue;<br>    return fallbackValue;<br>  }<br>  // Not found<br>  return undefined;<br>};</pre><h4>The Role of Atoms in My Solution</h4><p>You might be wondering: “Why atoms?” I’m using the <a href="https://jotai.org/">Jotai</a> library for state management, which provides several benefits:</p><ol><li><strong>Atomic state</strong>: Atoms are small pieces of state that can be updated independently</li><li><strong>Fine-grained updates</strong>: Only components subscribed to specific atoms re-render</li><li><strong>No context wrappers</strong>: Avoids the Provider hell of React Context</li><li><strong>Derived atoms</strong>: Create computed values that automatically update</li></ol><p>My implementation looks like this:</p><pre>// atoms/environment.ts<br>// Base atom for all environment variables<br>export const envAtom = atom&lt;EnvVariables&gt;({});</pre><pre>// Derived atoms for specific variables<br>export const apiVersionAtom = atom(<br>  (get) =&gt; get(envAtom).REMIX_API_VERSION || getFallbackValue(&#39;REMIX_API_VERSION&#39;)<br>);<br>export const cdnUrlAtom = atom(<br>  (get) =&gt; get(envAtom).REMIX_PUBLIC_CDN_URL || getFallbackValue(&#39;REMIX_PUBLIC_CDN_URL&#39;)<br>);</pre><p>This approach gives me both performance and type safety!</p><h4>How getFallbackValue Integrates with the System</h4><p>The getFallbackValue function is a critical part of my solution that serves multiple purposes:</p><ol><li><strong>Early access</strong>: It provides values for environment variables before React has fully initialized</li><li><strong>Default values</strong>: It ensures essential variables always have sensible defaults</li><li><strong>Error prevention</strong>: It stops apps from crashing due to missing environment variables</li><li><strong>Development ease</strong>: It makes local development possible without setting every variable</li></ol><p>In my system, it’s integrated at three key points:</p><ol><li><strong>Direct usage</strong>: Some code needs env vars before React loads</li><li><strong>Fallback in getters</strong>: My value getters use it when no other value is found</li><li><strong>Default in atoms</strong>: My derived atoms use it for their default values</li></ol><p>This multi-layered approach ensures my application always has the variables it needs, when it needs them!</p><h3>Why My Solution Rocks</h3><p>My approach provides several key advantages:</p><ul><li><strong>Better Security</strong>: No environment variables in HTML source</li><li><strong>Performance Optimized</strong>:</li><li>Caching at multiple levels</li><li>Atom-based for minimal re-renders</li><li>Specialized hooks for specific variables</li><li><strong>Developer Experience</strong>:</li><li>Type-safe using TypeScript</li><li>Easy to add new variables</li><li>Centralized fallback system</li><li><strong>Framework-Agnostic Pattern</strong>:</li><li>Works with Remix</li><li>Could be adapted to other frameworks</li><li>Uses standard React patterns</li></ul><h3>Bonus: Performance Monitoring</h3><p>I added performance monitoring in development mode to catch inefficient usage:</p><pre>// utils/performance.ts<br>// ✨ Add performance monitoring in development<br>window.__envPerfStats = () =&gt; {<br>  console.table(<br>    Object.keys(callCounts).map((key) =&gt; ({<br>      key,<br>      calls: callCounts[key],<br>      totalTime: callTimes[key].toFixed(2) + &#39;ms&#39;,<br>      avgTime: (callTimes[key] / callCounts[key]).toFixed(2) + &#39;ms&#39;,<br>    }))<br>  );<br>};</pre><h3>Ready to Use in Your Project</h3><p>Want to implement this solution in your own Remix application? I’ve created a GitHub Gist with the complete implementation that you can adapt to your project:</p><p><a href="https://gist.github.com/vitalii4reva/d7f9f503e9ad7d94832f326eb6e706e5">Secure Environment Variables for Remix (GitHub Gist)</a></p><p>Just copy the files into your project structure, adjust the imports, and you’re good to go!</p><h3>Common Mistakes to Avoid</h3><p>When working with environment variables in Remix, watch out for these common pitfalls:</p><h3>1. Inconsistent Variable Naming</h3><pre>// BAD: Inconsistent prefixing makes it hard to track what&#39;s public<br>export const loader = () =&gt; ({<br>  ENV: {<br>    PUBLIC_API_URL: process.env.PUBLIC_API_URL,<br>    apiVersion: process.env.API_VERSION, // Missing prefix!<br>    REMIX_PUBLIC_CDN: process.env.REMIX_PUBLIC_CDN, // Different prefix!<br>  }<br>});</pre><pre>// GOOD: Consistent prefixing<br>export const loader = () =&gt; ({<br>  ENV: {<br>    REMIX_PUBLIC_API_URL: process.env.REMIX_PUBLIC_API_URL,<br>    REMIX_PUBLIC_API_VERSION: process.env.REMIX_PUBLIC_API_VERSION,<br>    REMIX_PUBLIC_CDN: process.env.REMIX_PUBLIC_CDN,<br>  }<br>});</pre><h3>2. Accessing Environment Variables Directly</h3><pre>// BAD: Direct access bypasses security and type checking<br>function MyComponent() {<br>  // ❌ Don&#39;t do this!<br>  const apiUrl = window.__ENV__?.API_URL;<br>  // ...<br>}</pre><pre>// GOOD: Use the hook system<br>function MyComponent() {<br>  // ✅ Type-safe, secure, optimized<br>  const apiUrl = useApiUrl();<br>  // ...<br>}</pre><h3>3. Not Handling Server vs. Client Environments</h3><pre>// BAD: Will crash on server<br>const getEnvValue = (key) =&gt; {<br>  // ❌ This crashes on server<br>  return window.__ENV__[key];<br>}</pre><pre>// GOOD: Check environment<br>const getEnvValue = (key) =&gt; {<br>  // ✅ Works on both server and client<br>  if (typeof window === &#39;undefined&#39;) {<br>    return process.env[key];<br>  }<br>  // Client-side code here<br>}</pre><h3>Migration Strategy for Existing Projects</h3><p>If you already have a Remix application using the window.<strong>ENV</strong> approach, here’s how to migrate step by step:</p><h3>Step 1: Create the New System in Parallel</h3><p>First, set up the new system alongside your existing one:</p><ol><li>Create the hooks, atoms, and utility functions</li><li>Add the loader data returning ENV</li><li>Initialize the system in your root component</li></ol><h3>Step 2: Migrate Components Gradually</h3><p>Update your components one by one:</p><pre>// Before<br>function OldComponent() {<br>  const apiUrl = window.__ENV__.API_URL;<br>  // ...<br>}</pre><pre>// After<br>function NewComponent() {<br>  const apiUrl = useApiUrl();<br>  // ...<br>}</pre><h3>Step 3: Create a Compatibility Layer (Optional)</h3><p>If you have many components, you can create a compatibility layer:</p><pre>// compatibility.ts - Temporary file during migration<br>// This makes old code work with new system<br>window.__ENV__ = new Proxy({}, {<br>  get: (target, prop) =&gt; {<br>    console.warn(`Deprecated: Use hooks instead of window.__ENV__.${String(prop)}`);<br>    return getEnvValue(prop as keyof EnvVariables);<br>  }<br>});</pre><h3>Step 4: Remove Old System</h3><p>Once all components are migrated:</p><ol><li>Remove the compatibility layer</li><li>Remove the window.<strong>ENV</strong> script in entry.server.tsx</li><li>Remove any old environment variable handling code</li></ol><h3>Future Improvements</h3><p>While my current solution works well, there are some improvements I’m considering:</p><ol><li><strong>Environment Variable Validation</strong>: Add runtime schema validation using Zod or similar</li><li><strong>Build-time Analysis</strong>: Create a webpack/vite plugin to detect direct env var access</li><li><strong>Environment Switching</strong>: Add support for switching environments at runtime (dev/staging)</li><li><strong>Visual Debugging Tools</strong>: Create a dev panel showing all available environment variables</li><li><strong>Integration with Other State Management</strong>: Add support for Redux, Zustand and other popular libraries</li></ol><h3>Conclusion</h3><p>Environment variables in Remix don’t need to be a security vulnerability. By combining loader data, React hooks, atoms for state management, and a centralized fallback system, I’ve created a solution that’s:</p><ul><li>More secure than window.ENV</li><li>More flexible than Next.js build-time approach</li><li>More performant with optimized hooks and caching</li><li>Developer-friendly with TypeScript and monitoring</li></ul><p>The best part? The migration was seamless — my existing code using environment variables continued to work, but now with better security and performance!</p><p>What’s your approach to handling environment variables in Remix or other frameworks? Have you encountered similar security issues? Do you think my fallback system would work for your projects? Would you prefer a different state management approach than atoms?</p><p>I’d love to hear your thoughts and solutions in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a51297d3487" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Full-Stack React Developers? A Light Take on a New Trend]]></title>
            <link>https://vitalii4reva.medium.com/full-stack-react-developers-a-light-take-on-a-new-trend-7761c7cab360?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/7761c7cab360</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Sat, 28 Oct 2023 19:51:26 GMT</pubDate>
            <atom:updated>2023-10-29T10:57:19.356Z</atom:updated>
            <content:encoded><![CDATA[<p>Recently, at the Next Conf, a surprising snippet of code was showcased:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*geaWNkCRzN52lZtrc_AXUA.png" /></figure><p>At first glance, it seems like a lighthearted jest. A React component directly executing an SQL query? But, as time and technology progress, today’s joke can often become tomorrow’s reality.</p><p>Here’s why integrating frontend and backend in this manner might not be the future we’re looking for:</p><ol><li><strong>Security Concerns</strong>: Direct SQL can open doors to vulnerabilities like SQL injection, especially if inputs, such as slug, aren&#39;t handled with care.</li><li><strong>Muddling Logic</strong>: One cornerstone of software development is the separation of concerns. Ideally, frontend and backend remain distinct realms. This ensures modularity and makes the codebase more maintainable.</li><li><strong>Error Handling</strong>: Direct SQL in components leaves many questions. What if the query fails? Is there a retry mechanism?</li><li><strong>Profiling Challenges</strong>: Direct SQL within React components might make app profiling an uphill task.</li><li><strong>Optimization Issues</strong>: This can lead to a slew of unnecessary database queries, affecting performance.</li><li><strong>Scalability Concerns</strong>: Large-scale apps or ones with high traffic might struggle with this approach due to concurrent database access.</li><li><strong>Blurring Responsibilities</strong>: Here, the clear boundary between frontend and backend is lost.</li></ol><p>It’s often better to keep frontend and backend as separate entities: employ API endpoints for database interactions, letting frontend manage just data exchange.</p><p>On a lighter note, this revelation brought to mind a joke:</p><blockquote><strong><em>Developer 1</em></strong><em>: “So, you’re a full stack developer now? What’s your backend tech?”</em></blockquote><blockquote><strong><em>Developer 2</em></strong><em>: “React.”</em></blockquote><blockquote><strong><em>Developer 1</em></strong><em>: “No, I meant for the backend?”</em></blockquote><blockquote><strong><em>Developer 2</em></strong><em>: “Exactly, React! Now that we have direct SQL in components, React is my backend too!”</em></blockquote><blockquote><strong><em>Developer 1</em></strong><em>: “At this rate, our jokes about development will soon not be jokes anymore.”</em></blockquote><p>Conclusively, while embracing innovation is pivotal, it’s equally essential to prioritize secure, scalable, and maintainable coding practices.</p><p>Feedback, shares, and likes are welcome! If you’ve encountered similar innovative (or quirky) coding trends, do chime in with your experiences or thoughts!</p><p><strong>Update:</strong></p><p>In the near future, Next.js 27 will allow kernel interfacing at the component-level</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BT7HOQudq8kEgPrQ" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7761c7cab360" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web Development Time Capsule: 1991 — The Genesis of the World Wide Web]]></title>
            <link>https://vitalii4reva.medium.com/web-development-time-capsule-1991-the-genesis-of-the-world-wide-web-458f5a85e768?source=rss-8b5d6ffa844f------2</link>
            <guid isPermaLink="false">https://medium.com/p/458f5a85e768</guid>
            <category><![CDATA[internet-pioneers]]></category>
            <category><![CDATA[web-developmen]]></category>
            <category><![CDATA[digital-innovation]]></category>
            <category><![CDATA[technology-evolution]]></category>
            <category><![CDATA[world-wide-web]]></category>
            <dc:creator><![CDATA[Vitalii Petrenko]]></dc:creator>
            <pubDate>Sat, 28 Oct 2023 18:26:59 GMT</pubDate>
            <atom:updated>2023-10-28T18:32:11.401Z</atom:updated>
            <content:encoded><![CDATA[<h3>Web Development Time Capsule: 1991 — The Genesis of the World Wide Web</h3><p>Welcome to the inaugural article of our series, “Web Development Time Capsule.” In this collection, we’ll journey year by year, spotlighting the pivotal technologies, tools, and innovations that have shaped web development.</p><p>Our first stop: <strong>1991</strong>, a landmark year that witnessed the birth of the World Wide Web and set the stage for the digital revolution.</p><p>The late 20th century was a period of rapid technological advancement. Amidst this backdrop, one individual’s vision would lay the foundation for the modern internet as we know it. That individual was Tim Berners-Lee.</p><h4>Who is Tim Berners-Lee?</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7jhNzYOXhN9M2qxo" /></figure><p>Sir Tim Berners-Lee, a British computer scientist, is often hailed as the visionary behind the World Wide Web. Born in London in 1955 and an Oxford alumnus, Berners-Lee’s work at CERN in the late 1980s led him to conceptualize a system that harnessed hypertext to disseminate information on a global scale.</p><h4>The Emergence of Hypertext</h4><p>Hypertext, a system allowing text to link to other text, became the bedrock of the World Wide Web. While the concept of hypertext dates back to the 1960s, it was Berners-Lee’s foresight that recognized its potential to address CERN’s growing information management challenges. He envisioned a unified information system, facilitating seamless access and sharing of work among global researchers.</p><h4>NeXT: The Machine Behind the Revolution</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*uXLtbKiNYDIHX7ln.jpg" /></figure><p>After his departure from Apple in 1985, Steve Jobs founded NeXT Inc., focusing on producing computers for higher education and business markets. NeXT computers were known for their avant-garde design and cutting-edge technology. However, their high price point, often targeted at well-funded institutions, made them less accessible to the general public. Despite the steep price, the NeXT machines were instrumental in the early days of the web. It was on a NeXT computer that Tim Berners-Lee developed the first web browser, marking a significant milestone in the history of the internet.</p><h4>The Web’s Inception in 1991</h4><p>That vision came to life in 1991 when Berners-Lee introduced “WorldWideWeb,” the world’s first web browser and editor. Developed on the NeXT platform, this tool was not just for browsing but also for crafting web pages.</p><p>The rudimentary HTML of that era supported basic tags like &lt;head&gt;, &lt;title&gt;, &lt;body&gt;, and text formatting tags such as &lt;h1&gt; through &lt;h6&gt;, &lt;p&gt;, &lt;ul&gt;, &lt;ol&gt;, and &lt;li&gt;. Advanced features like images, styles, and interactivity were yet to be introduced.</p><p>Files were stored on a NeXT computer, which acted as the server. This machine was kept running continuously, ensuring that the information was always accessible to those who wanted to connect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LdLXm2D3vkhJyHfJ7Lnjwg.png" /></figure><p>Developers, in the absence of specialized tools, turned to basic text editors to create HTML documents. These initial web pages, devoid of graphics or intricate styling, primarily served as conduits for scientific information exchange.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*U_TjwuMG8O3fML3S" /></figure><p>Fast forward to today, and thanks to initiatives like CERN’s “Digital Archeology” project, we can revisit and appreciate the simplicity and ingenuity of those pioneering web pages.</p><p><a href="https://worldwideweb.cern.ch/browser/">Launch first web browser</a></p><h3>In Conclusion</h3><p>As we journey through the annals of web development history, it’s essential to pause and appreciate the visionaries and the groundbreaking technologies that paved the way for the digital world we inhabit today. The story of 1991 is just the beginning, and there’s so much more to explore in the subsequent years.</p><p>Thank you for joining me on this trip down memory lane. I hope you found this dive into 1991 as enlightening as I did.</p><p>Stay tuned for more insights in the next installment of our “Web Development Time Capsule” series. Thank you for reading, and until next time!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=458f5a85e768" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>