Coder Legion - Recent posts tagged blog

Top Ahrefs & Semrush Alternatives for Small Bloggers on a Budget

Fri, 16 Oct 2026 07:53:18 +0000

Ahrefs and Semrush are popular SEO platforms, but their subscription costs can be difficult for small bloggers to justify, particularly when a website is still building its audience. Paying for advanced keyword research, competitor analysis, backlink reports, and rank tracking may not make financial sense when a blog publishes only a few articles each month.

Fortunately, bloggers have other options. Some tools provide free website performance reports and technical SEO checks, while others offer keyword suggestions, backlink analysis, competitor research, and rank tracking through affordable subscriptions.

The best alternative depends on what a blogger needs to accomplish. Someone who wants to discover search queries that already bring visitors to a website has different requirements from someone researching competitors or planning a link-building campaign.

This guide examines six alternatives to Ahrefs and Semrush, covering their main uses, limitations, and suitability for small publishing businesses. The selection prioritizes practical SEO capabilities, free access where available, and subscription options that independent bloggers can evaluate before committing to a recurring expense.

Google Search Console: Best Free Alternative for Measuring Search Performance
Google Search Console is one of the first tools a blogger should use before paying for an SEO subscription. It provides information about how a website performs in Google Search, including impressions, clicks, click-through rates, and average search positions.

Unlike commercial SEO platforms, Search Console reports data about the website owner's own property rather than providing a complete commercial research database for analyzing competitors.

Key features include:

Search performance reports showing clicks, impressions, click-through rates, and average positions.

Queries and pages reports that help identify which content receives visibility in Google Search.

Indexing reports for investigating pages that Google has discovered or processed.

Tools for inspecting individual URLs and checking indexing information.

Sitemaps and other features that help website owners communicate with Google about their content.

Google provides Search Console without a subscription fee. Its official documentation and access point are available through Google Search Console.

Why small bloggers should consider it

Suppose a blogger publishes articles about personal finance, technology, or travel. Search Console can reveal queries that generate impressions even when those queries produce relatively few clicks. The blogger can investigate whether the relevant article adequately answers the searcher's question, whether its title accurately describes its content, and whether its introduction addresses the topic directly.

The same data can help identify older articles that deserve updating. A post that continues to appear in search results may offer an opportunity to improve its usefulness and presentation.

Limitations

Search Console does not replace a commercial keyword research platform. It is not designed to provide a comprehensive database of competitors' backlinks, estimated traffic, or keyword rankings across the entire market. Its search performance reports also concern Google Search, not every search engine.

Verdict: Start here if your priority is understanding your website's actual performance in Google Search without adding another monthly subscription.

Bing Webmaster Tools: Best Free Option for Additional SEO Research
Bing Webmaster Tools offers another free resource for bloggers who want to monitor website performance and investigate technical SEO issues.

Its official platform includes search performance information, backlink analysis, keyword research, site scanning, and diagnostic reports. These capabilities make it useful for bloggers who want more than a basic analytics dashboard.

The platform is available through Bing Webmaster Tools.

Key features include:

Keyword research: Explore search phrases and available search-volume information.

Backlink analysis: Examine referring pages, domains, and anchor text associated with your website.

Site Scan: Identify common technical issues through website crawling.

SEO reports: Review findings related to website health and potential optimization problems.

Search performance reports: Investigate how your website performs in Bing search results.

Why small bloggers should consider it

A blogger can use Bing Webmaster Tools to discover keyword ideas, examine links pointing to a website, and identify technical problems without immediately paying for a large SEO suite.

It is particularly useful alongside Google Search Console. Each platform provides information associated with its own search ecosystem, allowing publishers to monitor more than one search engine.

For example, a blogger could use Google's reports to investigate pages receiving impressions and Bing's keyword research features to explore additional search phrases. The resulting research can inform future articles and updates to existing content.

Limitations

Bing Webmaster Tools is not a complete substitute for Ahrefs or Semrush when conducting extensive competitor research. Its reports focus on the website and search ecosystem covered by the platform. Backlink and keyword information should not be assumed to match the coverage of a commercial SEO database.

Verdict: A strong free addition for bloggers who want keyword research, backlink information, and technical diagnostics without purchasing another subscription.

Ubersuggest: Best for Bloggers Seeking an Affordable All-in-One Tool
Ubersuggest is a commercial SEO platform that offers keyword research, competitor analysis, backlink information, rank tracking, and website auditing. It is worth considering for bloggers who prefer to manage several SEO tasks within one interface rather than rely entirely on separate free tools.

The platform also provides limited free access to keyword research features. Its available subscription plans and usage allowances can be reviewed on the official Ubersuggest pricing page.

Key features include:

Keyword suggestions for researching potential article topics.

Keyword metrics and search-volume estimates.

Competitor research for exploring websites and their organic search visibility.

Backlink reports for examining links and referring domains.

Rank tracking for monitoring selected keywords.

Site audits for identifying technical and on-page SEO problems.

Why small bloggers should consider it

Ubersuggest can help consolidate several routine publishing tasks. Instead of researching topics in one tool, checking backlinks in another, and monitoring rankings elsewhere, a blogger can use its available features for a broader view of SEO performance.

Consider a website that publishes tutorials about WordPress, website hosting, and digital marketing. Before writing an article, its owner can research related keywords, examine competing pages, and identify potential opportunities for a more useful article. After publication, rank tracking and site audits can help monitor the website's progress.

Ubersuggest offers paid options intended for different levels of website ownership and usage. Its pricing page lists an Individual plan at $29 per month and a Business plan at $49 per month under its monthly billing options. Prices and plan features can change, so check the current terms before subscribing.

Limitations

Ubersuggest is not a complete replacement for every capability available in Ahrefs or Semrush. Database coverage, reporting limits, tracked keyword allowances, and backlink information may differ. The right comparison should focus on the specific reports a blogger needs rather than the total number of features advertised.

Its estimates should also be treated as research indicators, not as guaranteed measurements of future traffic.

Verdict: A practical option for independent bloggers who want keyword research, competitor analysis, rank tracking, and site auditing in one paid platform without immediately committing to a higher-priced enterprise-oriented subscription.

Mangools: Best for Keyword Research and Search Result Analysis
Mangools is a collection of SEO tools designed to help users research keywords, inspect search engine results pages, monitor rankings, and examine backlink profiles. Its products include KWFinder, SERPChecker, SERPWatcher, LinkMiner, and SiteProfiler.

For small bloggers, Mangools is worth considering when keyword selection and search result analysis are more important than having every advanced SEO function in a single platform.

Its current products and subscription options are listed on the official Mangools website.

Key features include:

KWFinder: Research keywords and discover related search terms.

SERPChecker: Examine search results for a target keyword.

SERPWatcher: Monitor keyword rankings.

LinkMiner: Investigate backlinks.

SiteProfiler: Review website-level SEO information.

Why small bloggers should consider it

Keyword research can help a blogger decide which articles deserve attention before investing hours in writing. Mangools provides a collection of tools for examining keyword opportunities and the pages competing for search visibility.

For example, a blogger covering budget laptops could research a specific product category, examine the search results, and compare competing pages before deciding whether to publish a buying guide, comparison article, or troubleshooting tutorial.

The SERP analysis tools can also help publishers investigate the types of pages appearing for a query. This is useful when deciding whether an article should answer a question directly, compare products, or provide a detailed tutorial.

Mangools offers multiple subscription tiers with different usage limits. Its current pricing page lists a Basic plan, with keyword research, rank tracking, backlink analysis, and site analysis allowances varying by plan. Review the current billing terms and limits before purchasing.

Limitations

Mangools is a collection of specialized SEO tools, not a complete replacement for every feature in Ahrefs or Semrush. The number of searches, keyword suggestions, tracked rankings, and backlink records available depends on the subscription.

Verdict: Consider Mangools if you want dedicated keyword research and search result analysis tools without needing a large marketing platform.

Google Keyword Planner: Best for Generating Keyword Ideas
Google Keyword Planner is a keyword research tool available through Google Ads. Although its primary purpose is planning advertising campaigns, bloggers can also use it to discover search terms and investigate keyword demand.

Access is available through Google Ads Keyword Planner.

Key features include:

Discovering keyword ideas related to a product, service, topic, or website.

Reviewing estimated search volumes and trends.

Examining suggested keywords for a particular market.

Refining research using available geographic and language settings.

Organizing keyword ideas for further research.

Why small bloggers should consider it

A blogger does not necessarily need an expensive SEO platform to develop a list of relevant article topics. Keyword Planner can help generate ideas and investigate the language people use when searching for information.

Suppose you run a website about email marketing. You could begin with a broad topic such as email automation and examine related phrases covering tutorials, software comparisons, and common problems. Those ideas can become candidates for future articles.

Keyword Planner can also be useful for identifying related topics that a website has not covered yet. A blogger can combine these suggestions with existing website performance data from Google Search Console to decide which subjects deserve further investigation.

Limitations

Keyword Planner is designed for advertising research rather than comprehensive organic SEO analysis. It does not provide the same combination of competitor backlink intelligence, organic traffic estimates, and technical auditing offered by all-in-one SEO platforms.

Its search-volume figures should also be interpreted according to the information and ranges available in the account. Advertising estimates are not guarantees of organic traffic.

Verdict: A useful option for bloggers who primarily need keyword ideas and demand estimates, particularly when combined with free website performance data.

Ahrefs Free Tools: Best for Basic Website SEO Checks
Although this article focuses on alternatives to Ahrefs and Semrush, Ahrefs itself provides a free account with limited access to selected tools. That option deserves consideration because some bloggers may not need a complete replacement for the paid platform.

According to Ahrefs' official documentation, its free account includes access to Site Explorer and Site Audit for verified websites, along with other tools such as Web Analytics and its SEO Toolbar. Usage limits apply.

Details are available on the official Ahrefs pricing page.

Key features include:

Backlink and keyword information for websites you own and verify.

Site audits that identify technical and on-page SEO issues.

Website analytics with specified usage limits.

Selected SEO Toolbar metrics and on-page information.

Limited access to other Ahrefs features.

Why small bloggers should consider it

A blogger who already has access to free tools from Google and Bing may only need occasional backlink checks and technical audits. Ahrefs Free can help cover some of those requirements without immediately requiring a paid subscription.

For example, a publisher can use Site Audit to investigate technical issues on a verified website, then use Search Console to monitor search performance. This combination provides useful information without requiring the blogger to pay for every available SEO feature.

Limitations

The free account has significant restrictions. Ahrefs' documentation identifies limitations on report access, crawl credits, and available data. Its free account does not provide unrestricted access to the commercial keyword research and competitor analysis functions available through paid plans.

It is therefore better understood as a supplementary resource than as a complete substitute for Ahrefs' paid platform.

Verdict: Worth trying if you want selected Ahrefs capabilities while keeping your SEO expenses low.

How to Choose the Right Ahrefs or Semrush Alternative
The right choice depends on your website's stage of development, your publishing schedule, and the SEO tasks you perform most often.

Main Requirement

Recommended Tool

Monitor actual Google Search performance

Google Search Console

Access free keyword research and backlink information

Bing Webmaster Tools

Combine keyword research, rank tracking, and site audits

Ubersuggest

Research keywords and examine search results

Mangools

Generate keyword ideas and examine search demand

Google Keyword Planner

Run basic audits and inspect selected backlink data

Ahrefs Free

These tools are not identical. Their databases, reporting methods, search coverage, and usage limits differ. Compare the specific functions you need rather than assuming that a lower-priced subscription provides the same data as Ahrefs or Semrush.

Start with free tools
Before purchasing an SEO subscription, set up Google Search Console and Bing Webmaster Tools. Both provide useful information without a paid SEO subscription.

Use them to identify existing search queries, monitor website performance, and investigate technical issues. These initial steps can help establish which additional capabilities your website actually needs.

Identify the features you use regularly
Write down the tasks you perform each week. These might include researching keywords, checking competitors, tracking rankings, investigating backlinks, and auditing your website.

If you primarily research article topics, a keyword research tool may be sufficient. If you regularly analyze competitor link profiles, you will need a tool with suitable backlink reporting.

Compare total costs and usage limits
Do not compare subscriptions on price alone. Check how many websites you can manage, how many keywords you can track, whether backlink reports are included, and how frequently ranking data updates.

Review monthly and annual billing separately. Annual subscriptions may have lower effective monthly costs but require a larger upfront payment. Confirm the current price, renewal terms, cancellation policy, and any applicable taxes before subscribing.

Test tools against real publishing tasks
Use a tool to research a topic you genuinely intend to cover. Check whether it provides enough keyword ideas, useful search result information, and actionable data for your website.

Repeat the test with another tool before deciding. This approach is more useful than selecting software based on feature counts or promotional claims.

Remember that SEO tools do not guarantee rankings
SEO software provides research data and diagnostic information. It cannot guarantee that a page will rank highly or attract a particular number of visitors.

Google's official SEO Starter Guide emphasizes creating useful, reliable, people-first content and making websites easier for search engines to crawl and understand.

Use SEO tools to inform editorial decisions, not as a substitute for original research, accurate information, useful writing, and a technically accessible website.

Final Verdict
Small bloggers do not need to purchase the most expensive SEO platform simply because established publishers use it.

Google Search Console and Bing Webmaster Tools are the best starting points for bloggers who need to control costs. They provide useful website performance, keyword research, backlink, and diagnostic capabilities without requiring a paid SEO subscription.

Ubersuggest is worth evaluating when you want a broader collection of SEO functions in one paid tool. Mangools is another option for keyword research, search result analysis, and rank tracking. Google Keyword Planner is useful for generating keyword ideas, while Ahrefs Free can cover selected auditing and backlink research tasks.

The most sensible approach is to start with free tools, identify the limitations that interfere with your publishing workflow, and pay for additional capabilities only when you need them. That keeps SEO expenses under control while giving you practical data to guide your content strategy.

Hermes: Autonomous AI Agents for Career Growth and Opportunity Exploration

Sun, 11 Oct 2026 18:15:05 +0000

Hermes: Building Autonomous AI Agents for Career Growth and Opportunity Exploration
Building AI that does more than answer questions

Career development is becoming increasingly difficult to navigate.

For many people, improving their career does not simply mean finding a job. It can involve identifying suitable opportunities, understanding whether their existing skills are relevant, preparing applications, learning new skills, communicating with recruiters, evaluating different possibilities, and continuously looking for better opportunities.

At the same time, people whose income is limited or uncertain may also want to explore additional sources of income.

The challenge is not simply a lack of information.

There is already an enormous amount of information available.

The challenge is the time, effort, cost, and uncertainty involved in turning that information into useful and validated action.

This led to a question:

Can an AI system continuously observe opportunities, reason about them, take controlled actions, measure the results, and learn from those results while helping people improve their career prospects and explore additional opportunities with less unnecessary cost and risk?

That question became the starting point for Hermes.

What is Hermes?

Hermes is an autonomous AI-agent platform designed around a simple principle:

An intelligent system should not only generate an answer. It should be able to observe, reason, act, evaluate the outcome, and improve from experience.

The platform provides a common foundation for autonomous agents operating in different domains.

Two major applications currently demonstrate this architecture:

• Job Application Agent
• Algorithmic Trading Agent

The two agents solve very different problems, but they share the same underlying idea:

Observe → Reason → Act → Measure → Learn

The Regional Problem

West Bengal has experienced decades of industrial contraction, factory closures, lockouts, and business relocation. The consequences of these changes are not limited to individual employment events.

For workers and families, changes in employment can affect salary levels, financial stability, and the ability to invest in career development.

At the same time, professional career assistance, training, application services, and other forms of support can require money that people may not always be comfortable spending.

This creates a practical problem.

A person trying to improve their career may need to:

• Search across multiple job platforms
• Understand different job descriptions
• Determine whether their skills match
• Identify skill gaps
• Prepare applications
• Customize their CV
• Communicate with recruiters
• Follow up on applications
• Prepare for interviews
• Learn new skills
• Evaluate alternative career paths

Much of this work is repetitive and requires continuous attention.

There is also another dimension.

Someone looking to improve their financial position may want to explore additional income opportunities. But exploring an opportunity should not mean immediately risking scarce financial resources.

The goal should instead be to research, evaluate, and validate possibilities before committing significant time or money.

This led to the broader problem that Hermes attempts to address:

How can technology make career enhancement and opportunity exploration more accessible by reducing unnecessary time, effort, and cost while improving decision quality and introducing controlled validation before higher-risk actions?

Hermes is our exploration of that problem.

Agent 1: The Job Application Agent

The first major application of Hermes focuses on career development.

The Job Application Agent is designed to automate and assist with a large part of the employment-search workflow.

Instead of treating a job posting as a simple text document, the system processes the opportunity through multiple stages.

Job Discovery

↓

Job Description Understanding

↓

Qualification

↓

Skill Matching

↓

Skill-Gap Analysis

↓

Application Preparation

↓

ATS and Application Automation

↓

Application Tracking

↓

Outcome Analysis

↓

Learning

The objective is not simply to find more jobs.

It is to help identify opportunities that are more relevant to the candidate and reduce unnecessary effort in the application process.

Understanding the Job

A job description can contain much more than a list of keywords.

The system analyzes requirements such as:

• Required skills
• Preferred skills
• Experience requirements
• Eligibility conditions
• Role characteristics
• Technology requirements
• Other relevant constraints

This creates a structured representation of the opportunity that can then be evaluated against available candidate evidence.

Qualification Is Not Left Entirely to an AI Model

One important design decision in the Job Application Agent is that critical qualification decisions should not depend entirely on an unconstrained AI response.

The system contains deterministic qualification logic.

The qualification process considers multiple dimensions, including:

Eligibility
Candidate evidence
Job quality
Career fit
Application-channel readiness

The system can classify opportunities into states such as:

• QUALIFIED
• CONDITIONAL
• NEAR_MISS
• REJECT
• INSUFFICIENT_DATA

This creates a more explainable boundary between AI-assisted reasoning and deterministic decision logic.

The objective is not to make every candidate appear qualified.

The objective is to make the evaluation more useful and consistent.

Semantic Skill Matching

A simple keyword search can produce misleading results.

Two technologies may be related without being interchangeable.

Likewise, a candidate may possess transferable knowledge that is relevant even when the exact keyword does not appear in their existing CV.

Hermes therefore uses semantic skill relationships to distinguish between:

• Equivalent skills
• Related technologies
• Transferable skills
• Explicit incompatibilities
• Genuine missing requirements

This allows the system to reason about skill gaps instead of simply counting matching words.

Tailored Applications

Once an opportunity has been evaluated, the system can prepare application material around the specific job.

The objective is to avoid treating one generic CV as the correct representation for every opportunity.

The workflow can include:

Job Description

↓

Relevant Candidate Evidence

↓

Skill and Experience Selection

↓

Tailored CV

↓

ATS Preparation

↓

Application Submission

This allows the application process to be adapted to the actual requirements of each opportunity.

Application Tracking and Outcomes

An autonomous system should not stop after generating an application.

It needs to know what happened afterward.

The Job Application Agent tracks application activity and outcomes.

For example:

Application

↓

Submitted

↓

Recruiter or ATS Outcome

↓

Interview / Rejection / No Response

↓

Outcome Data

↓

Learning

This feedback can then be used to improve future opportunity selection and application strategies.

Learning From Application Outcomes

Every application creates an opportunity to learn.

Over time, the system can study patterns related to:

• Which opportunities were relevant
• Which applications produced responses
• Which skills were frequently requested
• Which skill gaps repeatedly appeared
• Which application approaches produced better outcomes
• Which opportunities resulted in interviews or other positive signals

The goal is to gradually improve the system's ability to prioritize useful opportunities and reduce wasted effort.

This creates an outcome-driven learning loop rather than a simple application generator.

Agent 2: Algorithmic Trading Research

The second application explores a very different type of opportunity: algorithmic trading.

This component requires a different safety philosophy.

The objective is not to tell financially vulnerable people to trade.

The objective is to investigate whether autonomous research and learning systems can discover, evaluate, and validate algorithmic trading skills in a controlled environment.

The architecture therefore begins with research rather than real-money execution.

Historical Market Data

↓

Market Research

↓

Feature Extraction

↓

Pattern and Hypothesis Discovery

↓

Candidate Trading Skill

↓

Historical Validation

↓

Paper Trading

↓

Outcome Measurement

↓

Learning and Reflection

↓

Further Validation

↓

Potential Future Controlled Execution

Why Paper Trading Matters

Paper trading is not the final objective.

It is a controlled evaluation stage.

Historical data can help determine whether a trading idea would have behaved differently under historical market conditions.

Paper trading provides another layer of evaluation by allowing the system to observe strategy behavior without immediately exposing real capital to an unvalidated approach.

The intended progression is:

Research

↓

Historical Validation

↓

Paper Validation

↓

Risk Validation

↓

Potential Future Real Execution

Any future transition toward real algorithmic option-chain execution should remain behind explicit validation and risk controls.

Market Intelligence and Option-Chain Research

The trading system is designed to work with much more than a simple price chart.

The research layer includes areas such as:

• Historical tick data
• Option-chain information
• Implied volatility
• Realized volatility
• IV surface
• IV skew
• IV term structure
• Gamma exposure
• Vanna
• Charm
• Market gaps
• Market microstructure
• Option Greeks
• Pattern research
• Outcome labeling

These signals are not treated as guarantees of future market movement.

Instead, they become inputs into a broader research and validation process.

A trading hypothesis must earn its way through validation.

The Common Learning Architecture

Although employment automation and algorithmic trading appear unrelated, they expose an important common pattern.

For the Job Application Agent:

Opportunity

↓

Understanding

↓

Evaluation

↓

Application

↓

Outcome

↓

Learning

For the Trading Agent:

Market Observation

↓

Research

↓

Hypothesis

↓

Validation

↓

Paper Trade

↓

Outcome

↓

Learning

For Hermes:

Observe

↓

Reason

↓

Plan

↓

Act

↓

Verify

↓

Measure Outcome

↓

Reflect

↓

Improve

The domain changes.

The learning architecture remains.

AI Does Not Mean Removing Control

One of the central engineering principles behind Hermes is that autonomy should not mean uncontrolled behavior.

Different decisions require different levels of freedom.

Some tasks benefit from AI reasoning.

Other tasks should remain deterministic.

AI-assisted reasoning can be used for activities such as:

• Understanding complex information
• Generating hypotheses
• Research
• Reasoning about alternatives
• Reflection on outcomes

Deterministic controls can handle areas such as:

• Eligibility constraints
• Risk limits
• Execution permissions
• Validation requirements
• Safety gates
• Kill switches

This separation becomes particularly important when an agent can take actions rather than simply produce text.

A Provider-Independent AI Architecture

Hermes is designed around a provider-independent AI layer.

Rather than embedding one model directly into every application, the platform uses a common AI routing architecture.

Tasks can be classified according to their purpose, including areas such as:

• Coding
• Code review
• Reasoning
• Research
• Trading research
• General work
• Reflexion

The routing layer determines which configured model capability should handle the task.

This creates a separation between agent logic and AI model infrastructure.

It also allows the underlying model infrastructure to evolve without requiring every agent to be redesigned.

Why This Architecture Matters

The goal of Hermes is not to create a single-purpose chatbot.

It is to create infrastructure for building agents that can operate through complete feedback loops.

A conventional AI workflow might look like:

Question → Answer

An autonomous workflow can look like:

Goal

↓

Observe

↓

Reason

↓

Plan

↓

Act

↓

Observe Result

↓

Evaluate

↓

Learn

↓

Improve Next Action

That difference is fundamental.

The system is not evaluated only by how good its answer looks.

It can also be evaluated by what happens after the answer is used.

What We Are Trying to Achieve

Hermes is not intended to promise employment.

It is not intended to guarantee income.

It is not intended to eliminate financial risk.

The trading component is also not intended to encourage people to immediately put money into markets.

Instead, the project explores a more practical goal:

Can autonomous AI reduce the cost and effort of career development and opportunity research while helping people make better-informed decisions and validate possibilities before taking larger risks?

For career development, that means reducing repetitive work and helping people focus more on relevant opportunities.

For additional income exploration, that means researching and validating possibilities rather than immediately committing scarce resources.

What Makes the Project Interesting

The interesting part of Hermes is not simply that it uses AI.

AI is already capable of generating text, summarizing documents, and answering questions.

The more difficult engineering problem is creating a system that can:

• Understand its environment
• Choose appropriate actions
• Use external tools
• Maintain state
• Verify results
• Collect outcomes
• Learn from previous attempts
• Operate within explicit safety boundaries

The Job Application Agent and Algorithmic Trading Agent provide two very different environments in which to test this architecture.

From Automation to Learning Systems

The long-term direction of Hermes is to move from isolated automation toward systems that improve through experience.

The intended learning loop is:

Experience

↓

Outcome

↓

Reflection

↓

New or Improved Skill

↓

Validation

↓

Better Action

↓

New Experience

The system does not assume that its first strategy is correct.

It gathers evidence.

It evaluates outcomes.

It improves.

Then it validates again.

The Road Ahead

There is still significant work ahead.

The next stages include:

• Expanding autonomous learning capabilities
• Improving skill-gap and opportunity analysis
• Strengthening outcome-based learning
• Improving trading-skill validation
• Increasing research coverage
• Strengthening safety and risk controls
• Expanding model-provider support
• Improving observability and evaluation
• Moving validated capabilities toward carefully controlled real-world execution

The principle remains the same:

Build first.

Measure.

Learn.

Validate.

Then expand.

Conclusion

Hermes started with a simple question:

What if AI could do more than tell us what to do? What if it could help carry out the work, observe what happened, and learn from the result?

The Job Application Agent applies that idea to career development.

The Algorithmic Trading Agent applies it to controlled research into a potential additional income pathway.

They are very different domains, but they share the same underlying architecture:

Observe → Reason → Act → Measure → Learn

The objective is not to promise a guaranteed job or guaranteed income.

It is to explore how autonomous AI can make career enhancement and opportunity exploration more accessible, systematic, and less wasteful, while keeping important actions behind appropriate validation and safety controls.

That is what we are building with Hermes.

Project Links

GitHub Repository: https://github.com/methakon/my-job-agent

Live Demo: https://berhampore.in (password protected will provide sublink letter)

Video Demonstration: comming soon

About the Project

Hermes is an evolving autonomous AI-agent platform. The project is being developed as a practical exploration of how AI agents can move beyond conversational assistance toward systems that can observe environments, perform actions, evaluate outcomes, and continuously improve through validated experience.

Build first. Measure. Learn. Validate. Then expand.

How to Streamline Your Blogging Workflow with Automation Tools

Tue, 29 Sep 2026 13:10:42 +0000

Running a blog involves far more than writing articles. A typical publishing process can include topic research, content planning, drafting, editing, SEO checks, image preparation, publishing, social media promotion, analytics, and follow-up tasks. When every step is handled manually, even a small publishing schedule can consume a significant amount of time.

Automation tools can reduce the repetitive work involved in this process. They can move information between applications, trigger tasks when specific events occur, schedule content for publication, and distribute new posts across multiple channels.

The objective is not to automate every part of blogging. Writing, editorial judgment, fact-checking, and strategic decisions still require human oversight. The practical goal is to automate predictable administrative tasks so more time can be spent producing useful content.

Start by Mapping the Blogging Workflow
Before connecting a collection of automation tools, document how a blog currently operates.

A basic workflow might look like this:

Find a topic.
Research the subject.
Add the idea to a content calendar.
Create an outline.
Write the article.
Edit and fact-check it.
Optimize the headline, metadata, links, and images.
Upload the article to the content management system.
Schedule or publish it.
Promote it on social media.
Record performance data.
Identify opportunities for future updates.
The most useful automation opportunities are usually the repetitive transitions between these stages.

For example, a new content idea could automatically create a task in a project-management database. When an article reaches an approved status, an automation could notify the editor. After publication, another workflow could send the article to a social media scheduling platform.

Mapping the process first prevents a common mistake: adding automation without understanding the workflow it is supposed to improve.

Use a Central Content Calendar
A content calendar provides a single location for tracking ideas, assignments, deadlines, publishing dates, and article status.

Tools such as Notion can be connected to automation platforms so that database activity triggers actions elsewhere. Zapier, for example, can use new Notion database items as triggers and create new database items or pages as actions.

A blogging database could include fields such as:

Article title
Primary keyword
Content category
Writer
Editor
Status
Draft deadline
Publication date
Target URL
Social promotion status
Update date
The important point is consistency. Every article should move through the same defined stages rather than relying on scattered notes, email messages, and spreadsheets.

Automate Repetitive Administrative Tasks
Automation platforms are particularly useful when a task follows a predictable trigger-action pattern.

Zapier describes its workflows as combinations of triggers and actions. A trigger starts the workflow, while subsequent actions perform predefined tasks. Its current platform supports thousands of applications and also provides AI-assisted workflow creation.

Consider a simple example. A writer changes an article's status in a content database from "Draft" to "Ready for Review." That change could trigger a notification to an editor.

Another workflow could create a task when a new content idea is added to a database.

These automations do not write the article. They eliminate repetitive coordination work.

That distinction matters. Automation should handle predictable processes while editorial decisions remain under human control.

Connect Your Content Calendar to WordPress
WordPress provides built-in scheduling, allowing posts and pages to be configured for publication at a future date and time. The WordPress.com documentation also notes that the site's timezone affects when scheduled content is published.

For publishers who want a more connected workflow, WordPress can also be integrated with automation platforms.

Zapier's WordPress integration supports triggers and actions associated with posts, comments, users, and media. This can allow events inside WordPress to trigger activities in other applications.

For example, a content operation could use an automation to:

Create a WordPress draft from an approved content record.
Notify a team when a post is published.
Record a newly published URL in a content database.
Trigger a downstream social media workflow.
The automation should be tested carefully before being used for production publishing. A faulty workflow can duplicate content, publish incomplete drafts, or send incorrect information to other platforms.

Automate Social Media Distribution
Publishing an article is only one part of content distribution. Social media promotion can introduce another series of repetitive tasks, particularly for publishers managing multiple channels.

Buffer provides a WordPress integration that can automatically add newly published blog posts to a social media queue. Its documentation describes a workflow in which a new WordPress post can be sent to Buffer automatically after publication.

Buffer can also connect with automation services such as Zapier, Make, IFTTT, and n8n. These integrations can use triggers and actions to create posts or ideas and move information into Buffer without requiring every step to be performed manually.

A practical workflow could therefore look like:

New WordPress post → automation trigger → social media draft → scheduled distribution.

The editorial team can still review the social copy before publication. Automation simply moves the information from one stage to another.

Use AI Where It Saves Time, Not Where Accuracy Matters Most
AI tools can assist with several parts of a blogging workflow, including brainstorming, outlining, summarization, headline variations, content repurposing, and routine editing.

However, AI-generated material should not bypass editorial review. Automated output can contain factual errors, unsupported claims, incorrect terminology, or information that is no longer current.

A more reliable workflow is to use AI as an assistant within defined stages.

For example:

Topic research → human verification → AI-assisted outline → human-written or reviewed draft → fact-checking → editing → publication.

This approach separates productivity gains from editorial responsibility.

AI can also be incorporated into broader automation workflows. Zapier currently provides AI features that can help users create workflows and troubleshoot workflow errors, while its automation system remains based on defined triggers and actions.

Build Automated Content Notifications
Team communication is another area where automation can reduce unnecessary manual work.

Suppose an article moves into an "Approved" status. Instead of an employee checking the content calendar repeatedly, the workflow could send a notification to the person responsible for publication.

Similar triggers could notify a team when:

A draft is ready for editing.
An article has been approved.
A scheduled publication date is approaching.
A post has gone live.
A social media draft has been created.
A required content field is missing.
These small automations become more valuable as the publishing operation grows.

Automate Reporting Without Automating the Analysis
Blogging produces large amounts of performance information. Traffic, search visibility, conversions, engagement, and social activity can become difficult to track manually.

Automation can help collect or organize this information, but the interpretation should remain deliberate.

For example, a workflow might transfer selected campaign information into a reporting spreadsheet or database. The content team can then review the data and decide which topics deserve additional coverage or updating.

The goal is not to create a dashboard full of numbers. The goal is to reduce the administrative work required to obtain the information needed for editorial decisions.

Keep Human Review at Critical Checkpoints
The biggest mistake in blogging automation is treating automation as a replacement for editorial judgment.

Several checkpoints should remain under human control:

Factual verification
Source evaluation
Legal or compliance review
Final editing
Brand voice
Sensitive topics
Claims about products or companies
Final publication approval
Automation should make these checkpoints easier to manage, not eliminate them.

A useful principle is simple: automate the process around the content, but maintain human responsibility for the content itself.

Start With One Workflow
A blogging operation does not need dozens of automations on the first day.

Start with one repetitive process that occurs frequently and has a clear trigger and predictable outcome.

For example:

New blog post published → automatically create a social media draft.

Once that workflow operates reliably, another can be added:

New approved content idea → automatically create an assignment in the project-management system.

Then another:

Article marked ready for review → automatically notify the editor.

This incremental approach makes it easier to identify errors and measure whether an automation is actually saving time.

The Goal Is a More Efficient Publishing System
Blogging automation works best when it removes repetitive administrative work without removing editorial control.

A modern workflow can combine a content database, an AI assistant, an automation platform, WordPress, and a social media scheduling service. Notion can manage structured content information, Zapier can connect applications and trigger actions, WordPress can handle scheduled publishing, and Buffer can help distribute published content across social channels.

The most effective setup will depend on the publication's size, publishing frequency, team structure, and existing software.

The important first step is not buying more software. It is identifying which blogging tasks are repetitive, predictable, and time-consuming. Those tasks are the strongest candidates for automation.

Once those processes are documented and connected, bloggers and content teams can spend less time moving information between applications and more time researching, writing, editing, and improving the content that audiences actually read.

How to Find SEO Issues Before Publishing a Blog Post

Sun, 20 Sep 2026 14:53:38 +0000

Publishing an article without a final SEO check can lead to indexing, ranking, speed, and internal-linking problems.
Here’s a quick pre-publishing SEO checklist you can use before hitting “Publish.”

Check Search Intent
Make sure your article actually answers what people are searching for. Look at the current search results and identify the questions and information users expect.
**Optimize the Title & Meta Description**
Your title should clearly explain the page topic and include your primary keyword naturally. Write a useful meta description that encourages clicks without keyword stuffing.
Review Your Headings
Use a logical structure:
H1 → H2 → H3
Each section should cover a specific part of the topic.
Check Keyword Usage
Use your primary and related keywords naturally. Don't repeat a keyword just to increase keyword density.
Focus on answering the reader's question thoroughly.
Check Internal Links
Add relevant links to other articles and tools on your website. Internal linking helps readers discover related content and helps search engines understand your site's structure.
Optimize Images
Before publishing:
Compress large images
Use descriptive filenames
Add useful alt text
Avoid unnecessarily large dimensions
Test Mobile & Page Speed
Check how the page looks on mobile and test its performance. Pay particular attention to layout shifts, large images, and unnecessary scripts.
Check Indexing & Canonical
Make sure the page isn't accidentally set to noindex and that the canonical URL points to the correct page.
Check Structured Data
If structured data is relevant to your content, validate it before publishing. Don't add schema simply because it exists—use markup that accurately describes the page.
Use Google Search Console After Publishing
Once the article is live, inspect the URL in Search Console and monitor:
Impressions
Clicks
Queries
Average position
Indexing status
SEO doesn't end when you publish. Publishing is the beginning of the measurement phase.
Final checklist
Before publishing, ask:
Does this article satisfy search intent?
Is the information genuinely useful?
Is the page technically accessible?
Are internal links relevant?
Does it work well on mobile?
Can Google understand the page?
A simple checklist like this can catch many SEO problems before they become ranking problems.
Related: If you want to audit your pages after publishing, try an SEO analyzer to identify technical and on-page issues.

Should Your Business Have a Blog? The Honest Answer

Sun, 06 Sep 2026 08:41:57 +0000

"You should be blogging" is advice given to nearly every business regardless of what they actually do, which is exactly why it's worth questioning rather than accepting automatically. A blog is a real, ongoing commitment, and for some businesses it's genuinely one of the highest-leverage things they can do. For others, it's a slow drain on time that never produces a meaningful return. Here's how to actually tell which situation you're in.

What a Blog Actually Does, When It Works

A business blog's real function is capturing search traffic for the specific questions your potential customers are already asking, before they know your specific business exists. Someone searching "how much does a website cost" isn't searching for you by name, they're searching for an answer, and a genuinely useful post answering that question is how a stranger becomes aware you exist in the first place.

Done well, this compounds over time in a way paid advertising doesn't. A well-ranking post keeps bringing in visitors for years after it's published, without ongoing spend, which is fundamentally different from ad traffic that stops the moment the budget does.

Why It Fails for a Lot of Businesses

Publishing without a real strategy behind it. A blog with no clear picture of what specific questions its actual customers are searching for tends to produce content that satisfies nobody, too generic to rank well, too unfocused to convert the traffic it does get.

Inconsistency. A blog with three posts, the last one from over a year ago, actively signals neglect rather than helping at all, undermining trust more than an absent blog would have. Half-committing is often worse than not starting.

Content that doesn't match how the business actually makes money. A blog can drive real traffic and still contribute nothing to revenue if the topics never connect back to what the business actually sells or the decisions its real customers are making.

The Real Question: Does Your Business Have Genuine Search Demand

This is the question that actually determines whether blogging makes sense, more than any generic advice about content marketing. Some businesses serve markets where real people are actively searching for answers related to what that business does, web development, health topics, financial questions, genuinely broad categories with real search volume behind specific questions. Other businesses serve markets where almost nobody is searching anything relevant, a highly local service with no informational search behavior around it, a business reached almost entirely through referral or existing relationships rather than search.

A blog makes sense if: real people are genuinely searching questions related to what you do, your sales cycle benefits from building trust and demonstrating expertise before a first conversation, or you're competing in a market where content-driven authority genuinely influences buying decisions.

A blog probably doesn't make sense, at least not as a priority, if: your actual customer base finds you almost entirely through referral or existing relationships, there's minimal genuine search volume for anything related to what you do, or the time a blog would require is better spent on something with a clearer, faster return for your specific business right now.

What "Doing It Well" Actually Requires

Genuine topic research, not guessing at what might be interesting, actually finding what your real potential customers are searching, and answering those specific questions directly and thoroughly.

Real consistency, a realistic, sustainable publishing rhythm you can actually maintain, rather than an ambitious schedule that collapses after a month and leaves a visibly abandoned blog behind.

Content that connects back to what you actually offer. Not every post needs a hard sell, but a consistent pattern of content that never relates back to your actual business rarely converts, regardless of how much traffic it generates.

Patience with the actual timeline. Blog content typically takes months, not weeks, to start producing meaningful search traffic, and treating it as a quick-win channel usually leads to abandoning it right before it would have started working.

What to Do Instead, If a Blog Genuinely Isn't the Right Fit

Not every business needs to force this specific channel. Referral programs, direct outreach, partnerships, or paid channels with a faster, clearer feedback loop can be a genuinely better use of the same time and effort for a business whose actual customers aren't finding solutions through search behavior in the first place. The honest goal is matching effort to where your specific customers actually are, not defaulting to blogging because it's common generic advice.

Frequently Asked Questions

How long does it take for a business blog to start producing real results?
Meaningful organic traffic typically takes several months to begin building, and real, consistent results often take closer to a year of sustained, genuinely useful publishing. This is one of the biggest reasons blogs get abandoned prematurely, right around the point they'd realistically start working.

How often should a business actually publish blog content?
A sustainable, realistic cadence maintained consistently outperforms an ambitious schedule that collapses after a few months. Once every week or two, genuinely maintained for a year, produces far more real value than daily posting for a month followed by silence.

Can a blog work for a very niche or local business?
Yes, if there's genuine search demand around the specific niche or local area, even at a smaller volume than a broader market would have. The key question stays the same regardless of niche size, is there real search behavior to capture, not whether the specific topic sounds broad enough to justify a blog.

If you're trying to figure out whether a blog is actually the right investment for your specific business, I'm happy to give an honest read on whether the search demand is genuinely there.

Get in touch: https://pixelanas.com/contact

Anas, full-stack Next.js developer building SaaS products and premium templates. X: @ASheikh69751

next-mdx-remote-client Guide for Next.js 16 (2026)

Fri, 28 Aug 2026 03:40:16 +0000

If you followed our original MDX blog setup guide, you already have a working blog powered by next-mdx-remote. There's just one problem: HashiCorp archived that repo on April 9, 2026. The package still runs fine today — nothing breaks overnight — but it's now frozen. No new features, no security patches, no fixes if a future Next.js or React release changes something it depends on.

That's not a reason to panic, but it is a reason to plan your next move. The community's answer is next-mdx-remote-client — an actively maintained fork that keeps the same mental model (compile MDX on the server, render it as React) while fixing several rough edges the original never got around to, including a proper built-in error boundary and support for export statements inside MDX on the App Router.

This guide walks through the same MDX blog setup as before, rebuilt from scratch on next-mdx-remote-client — content folder, typed data layer, custom components, syntax highlighting, and dynamic SEO metadata — so you can migrate confidently or start fresh if you're building a new Next.js 16 blog today.

Note: This guide targets the App Router using next-mdx-remote-client's React Server Component API (the /rsc subpath). If you're on the Pages Router, the package has a separate, isolated API for that too — see the FAQ at the end.

Why next-mdx-remote-client Instead of next-mdx-remote?

Both packages solve the same problem: MDX content stored outside your app folder — a content/blogs directory, a database, a CMS — rendered through one dynamic [slug] route, instead of every post being its own route file under @next/mdx.

While the original next-mdx-remote was the long-time standard for this pattern, its archiving means developers need a modern alternative. next-mdx-remote-client has emerged as the community's go-to, actively maintained drop-in replacement built specifically for the App Router. A few concrete differences that actually matter day to day:

Feature	`next-mdx-remote`	`next-mdx-remote-client`
Actively maintained	❌ Archived April 2026	✅
Built-in error handling in App Router	❌ You wrap it yourself	✅ `onError` prop
`export` statements from MDX in App Router	❌	✅
Get frontmatter + scope without a separate parse step	❌	✅ (`evaluate` function)
Utility to read frontmatter without compiling	❌	✅ `getFrontmatter`
MDX version	3	3

What "built-in error handling" actually buys you: with next-mdx-remote, a broken MDX file (a stray { in an expression, an unclosed JSX tag) throws during render, and it's on you to catch it with an ErrorBoundary. next-mdx-remote-client's MDXRemote component takes an onError prop directly, so a bad post shows a friendly fallback instead of crashing the whole page — which matters a lot the first time a typo in frontmatter takes down your blog in production.

💡 Tip: next-mdx-remote-client requires React 19.1+ and is tested against Next.js 15 and 16. If your project is still on React 18, install the @^1 tag instead — see Step 1.

A Quick Word on Security

Before writing any code: MDX compiles to executable JavaScript. That's what makes <Component /> tags work inside your Markdown, but it also means rendering MDX from a source you don't fully control (user submissions, an open CMS) can enable XSS or even remote code execution — this is true of every MDX renderer, not something specific to this package.

For a personal or team blog where you're the only one writing .mdx files, this isn't a practical concern — you already trust your own content. If you ever accept MDX from outside contributors, strip dangerous expressions at the remark stage first (the maintainer's own remark-mdx-remove-expressions plugin is built for exactly this) rather than trying to sanitize after the fact.

Prerequisites

This guide uses:

Next.js 16 with the App Router
React 19.2+
TypeScript in strict mode
Node.js 20.9+

We'll build:

MDX files stored in a content/blogs folder
A reusable getAllPosts() / getPostBySlug() data layer
Custom-styled MDX components (headings, code blocks, links, tables)
Syntax highlighting with sugar-high
remark-gfm for GitHub-flavored Markdown (tables, strikethrough, task lists)
Built-in error handling via onError
Dynamic SEO metadata and JSON-LD structured data per post

Step 1: Install Dependencies

npm install next-mdx-remote-client gray-matter remark-gfm reading-time sugar-high

Since when this matters is the whole point of this migration, be explicit about which major version you need:

# React 19 projects (the default for new Next.js 16 apps)
npm install next-mdx-remote-client@^2

# React 18 projects
npm install next-mdx-remote-client@^1

What each package does:

Package	Purpose
`next-mdx-remote-client`	Compiles and renders MDX strings as React, with built-in error handling
`gray-matter`	Parses frontmatter for the post-listing data layer
`remark-gfm`	Adds GitHub-flavored Markdown — tables, strikethrough, task lists
`reading-time`	Calculates estimated reading time from post content
`sugar-high`	Lightweight, zero-client-JS syntax highlighter for code blocks

⚠️ Common Mistake: Importing from next-mdx-remote-client directly. The package splits its App Router and Pages Router code into separate, isolated subpaths — for the App Router you always import from next-mdx-remote-client/rsc, never the bare package name. We'll use that subpath throughout this guide.

Step 2: Content Folder and Frontmatter (Unchanged)

If you're migrating from the original guide, this part doesn't change at all — next-mdx-remote-client reads the same MDX files.

content/blogs/hello-world.mdx

---
title: "Hello World: My First MDX Post"
description: "A short example post to test out the next-mdx-remote-client setup."
publishedAt: "2026-08-20"
tags: ["MDX", "Next.js"]
featured: false
---

## Hello World

This is my **first** MDX post rendered with `next-mdx-remote-client`.

- It supports Markdown
- It supports *React components*
- It even supports tables (thanks to remark-gfm)

| Feature            | Supported |
| ------------------ | --------- |
| Tables             | ✅       |
| Code blocks        | ✅       |
| Custom components  | ✅       |

Keep frontmatter field names consistent across every post (title, description, publishedAt, tags). A typo like date instead of publishedAt on one file will silently break sorting for that post, since your data layer expects an exact key.

Step 3: Build the Data Layer

This file reads every .mdx file from disk, parses frontmatter with gray-matter, and returns typed post objects for your listing page. This part still uses gray-matter on purpose — it's what powers the blog index (getAllPosts), which needs frontmatter without compiling MDX for every post just to render a list.

// lib/posts.ts
import fs from "fs";
import path from "path";
import matter from "gray-matter";
import readingTime from "reading-time";

const POSTS_PATH = path.join(process.cwd(), "content/blogs");

export type Post = {
  slug: string;
  title: string;
  description: string;
  publishedAt: string;
  updatedAt?: string;
  tags: string[];
  readingTime: string;
  content: string;
};

export function getAllPosts(): Post[] {
  const files = fs.readdirSync(POSTS_PATH);

  const posts = files.map((file) => {
    const filePath = path.join(POSTS_PATH, file);
    const fileContent = fs.readFileSync(filePath, "utf-8");

    const { data, content } = matter(fileContent);

    const slug = file.replace(/\.mdx$/, "");

    return {
      slug,
      title: data.title,
      description: data.description,
      publishedAt: data.publishedAt,
      updatedAt: data.updatedAt,
      tags: data.tags || [],
      readingTime: readingTime(content).text,
      content,
    };
  });

  return posts.sort(
    (a, b) =>
      new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime()
  );
}

export function getPostBySlug(slug: string) {
  return getAllPosts().find((post) => post.slug === slug);
}

💡 Tip — an alternative worth knowing: next-mdx-remote-client ships its own getFrontmatter utility that reads frontmatter without compiling the MDX, using the same vfile-matter extractor internally:
import { getFrontmatter } from "next-mdx-remote-client/utils";

const { frontmatter, strippedSource } = getFrontmatter<Post>(fileContent);
It's isolated in its own subpath and costs almost nothing to import, so it's a reasonable way to drop the gray-matter dependency entirely if you're starting fresh. This guide keeps gray-matter since it's already a common dependency in most Next.js content setups and behaves identically either way.

💡 Tip: lib/posts.ts uses Node's fs module, so it only runs on the server — inside Server Components, generateStaticParams, or generateMetadata. Never import it into a "use client" component.

Step 4: Create Custom MDX Components

The component map itself is unchanged from a next-mdx-remote setup — this is standard @mdx-js/mdx behavior, and next-mdx-remote-client uses the same convention.

// mdx-components.tsx
import React, { ComponentPropsWithoutRef } from "react";
import Link from "next/link";
import { highlight } from "sugar-high";
import type { MDXComponents } from "next-mdx-remote-client/rsc";

type HeadingProps = ComponentPropsWithoutRef<"h1">;
type ParagraphProps = ComponentPropsWithoutRef<"p">;
type ListProps = ComponentPropsWithoutRef<"ul">;
type AnchorProps = ComponentPropsWithoutRef<"a">;
type BlockquoteProps = ComponentPropsWithoutRef<"blockquote">;

export const mdxComponents: MDXComponents = {
  h1: (props: HeadingProps) => (
    <h1 className="scroll-m-20 text-4xl font-bold tracking-tight lg:text-5xl" {...props} />
  ),
  h2: (props: HeadingProps) => (
    <h2 className="scroll-m-20 mt-16 pb-2 text-3xl font-semibold tracking-tight" {...props} />
  ),
  h3: (props: HeadingProps) => (
    <h3 className="scroll-m-20 mt-12 text-2xl font-semibold tracking-tight" {...props} />
  ),
  p: (props: ParagraphProps) => (
    <p className="text-gray-800 dark:text-zinc-300" {...props} />
  ),
  ul: (props: ListProps) => (
    <ul className="text-gray-800 dark:text-zinc-300 list-disc pl-5 space-y-1" {...props} />
  ),
  a: ({ href, children, ...props }: AnchorProps) => {
    const className = "text-blue-500 hover:text-blue-700";

    if (href?.startsWith("/")) {
      return (
        <Link href={href} className={className} {...props}>
          {children}
        </Link>
      );
    }

    return (
      <a href={href} target="_blank" rel="noopener noreferrer" className={className} {...props}>
        {children}
      </a>
    );
  },
  code: ({ children, ...props }: ComponentPropsWithoutRef<"code">) => {
    const codeHTML = highlight(String(children));
    return <code dangerouslySetInnerHTML={{ __html: codeHTML }} {...props} />;
  },
  blockquote: (props: BlockquoteProps) => (
    <blockquote className="ml-[0.075em] border-l-3 border-green-400 pl-4 text-gray-700" {...props} />
  ),
};

What's different here from a next-mdx-remote setup: the MDXComponents type now comes from next-mdx-remote-client/rsc instead of mdx/types — the package re-exports it so you don't need a separate import. Everything else, including the special wrapper key if you want to wrap MDX content in a container element, works exactly the same way.

Step 5: Build the Dynamic Blog Route

This is where the actual migration happens. Swap the import source and add the onError prop — the rest of the route looks familiar if you've built this with next-mdx-remote before.

// app/blog/[slug]/page.tsx
import { Suspense } from "react";
import { notFound } from "next/navigation";
import { MDXRemote, type MDXRemoteOptions } from "next-mdx-remote-client/rsc";
import remarkGfm from "remark-gfm";
import { getAllPosts, getPostBySlug } from "@/lib/posts";
import { mdxComponents } from "@/mdx-components";
import ErrorComponent from "@/components/error-component";

interface BlogPostPageProps {
  params: Promise<{ slug: string }>;
}

// Pre-renders every post at build time (Static Site Generation)
export async function generateStaticParams() {
  const posts = getAllPosts();
  return posts.map((post) => ({ slug: post.slug }));
}

export async function generateMetadata({ params }: BlogPostPageProps) {
  const { slug } = await params;
  const post = getPostBySlug(slug);

  if (!post) return {};

  return {
    title: post.title,
    description: post.description,
  };
}

const mdxOptions: MDXRemoteOptions = {
  mdxOptions: {
    remarkPlugins: [remarkGfm],
  },
};

export default async function BlogPostPage({ params }: BlogPostPageProps) {
  const { slug } = await params;
  const post = getPostBySlug(slug);

  if (!post) {
    notFound();
  }

  return (
    <article className="prose dark:prose-invert mx-auto">
      <h1>{post.title}</h1>

      <Suspense fallback={<p>Loading post…</p>}>
        <MDXRemote
          source={post.content}
          components={mdxComponents}
          options={mdxOptions}
          onError={ErrorComponent}
        />
      </Suspense>
    </article>
  );
}

Create Error component

// components/error-component.tsx

'use client'

export default function ErrorComponent({ error }: { error: unknown | Error }) {
    return (
        <div className="rounded-xl border border-destructive/30 bg-destructive/5 p-4 text-sm text-destructive">
            <pre>
                <code>
                    {typeof error === "string"
                        ? error
                        : error instanceof Error
                            ? error.message
                            : String(error)}
                </code>
            </pre>
        </div>
  );
}

What's actually new compared to next-mdx-remote:

import { MDXRemote } from "next-mdx-remote-client/rsc" — the App Router entry point. Importing from the bare package name here would pull in the Pages Router code path instead, which won't work.
<Suspense> is required, not optional. MDXRemote is an async Server Component under the hood — it returns a Promise<React.JSX.Element> — so it needs a Suspense boundary the same way any other async Server Component does.
onError={ErrorComponent} is the headline feature from earlier. If this specific post's MDX fails to compile — a syntax error like an unclosed tag, or a bad frontmatter parse — MDXRemote catches it internally and renders ErrorComponent in its place, instead of taking down the whole page.
options.mdxOptions.remarkPlugins still works exactly the way next-mdx-remote did — remark-gfm plugs in the same way for tables and GFM syntax.

⚠️ Common Mistake: Forgetting the <Suspense> wrapper. Since MDXRemote is async, rendering it directly without a Suspense boundary will throw a build error telling you an async component needs one — this is a hard requirement of the package, not a style suggestion.

💡 Tip: Notice onError catches compile/render errors caught by the package's internal handling, but the README is explicit that evaluating the compiled module itself doesn't throw except syntax errors — some render-time errors from a broken custom component can still escape and need a real React <ErrorBoundary> around your route if you want to be fully defensive. For a typical blog where you control every MDX file, onError alone covers the realistic failure cases (a bad frontmatter reference, a malformed table, an unclosed tag).

If you want to deep dive into Error Handling in Next.js, I've full guide covering this topic here.

Step 6: Want Frontmatter and Scope Inside JSX? Use `evaluate` Instead

The MDXRemote component above is enough if you only need frontmatter and custom data inside the MDX body (e.g. # {frontmatter.title} written directly in the .mdx file). If you need that data outside the MDX, in your page's own JSX — for a byline, a reading-time badge, a table of contents component — reach for the lower-level evaluate function instead.

Update lib/posts.ts

// lib/posts.ts
export const getSource = async (filename: string): Promise<string | undefined> => {
    const sourcePath = path.join(POSTS_PATH, filename);
    if (!fs.existsSync(sourcePath)) return;
    return await fs.promises.readFile(sourcePath, "utf8");
};

// app/blog/[slug]/page.tsx (alternative using evaluate)
import { Suspense } from "react";
import { evaluate, type EvaluateOptions } from "next-mdx-remote-client/rsc";
import remarkGfm from "remark-gfm";
import { getSource } from "@/lib/posts";
import { mdxComponents } from "@/mdx-components";
import ErrorComponent from "@/components/error-component";

interface BlogPostPageProps {
    params: Promise<{ slug: string }>;
}

type Frontmatter = {
  title: string;
  description: string;
};

const mdxOptions: MDXRemoteOptions = {
    parseFrontmatter: true,
    mdxOptions: {
        remarkPlugins: [remarkGfm],
    },
};

export default async function BlogPostPage({ params }: BlogPostPageProps) {
    const { slug } = await params;
    const source = await getSource(`${slug}.mdx`)!;

    if (!source) return <ErrorComponent error="The source could not found!" />;

  const { content, frontmatter, error } = await evaluate<Frontmatter>({
    source,
    options: mdxOptions,
    components: mdxComponents,
  });

    if (error) return <ErrorComponent error={error} />;

  return (
    <article className="prose dark:prose-invert mx-auto">
      <h1>{frontmatter.title}</h1>
            <Suspense fallback={<p>Loading post…</p>}>
                {content}
            </Suspense>
    </article>
  );
}

What's happening here: evaluate returns { content, mod, frontmatter, scope, error } all at once — content is the compiled MDX JSX (still needs its own <Suspense>), frontmatter is typed and available immediately for use in your surrounding JSX, and error is a plain object you check yourself instead of a component prop. This is the tool to reach for whenever you need frontmatter or a table-of-contents object before the MDX renders, not just inside it — the MDXRemote component genuinely can't do this on the App Router, since it doesn't hand you the frontmatter as a return value at all.

💡 Tip: Passing parseFrontmatter: true here means evaluate extracts frontmatter itself — you could skip gray-matter entirely for a page that only needs a single post. This guide's lib/posts.ts still uses gray-matter separately because the blog index page needs frontmatter for every post at once, without compiling every post's MDX just to list titles.

Step 7: Add JSON-LD Structured Data (Optional, but Great for SEO)

Unchanged from the original setup — this is a Next.js <Script> tag, not something the MDX package touches.

// app/blog/[slug]/page.tsx (addition)
import Script from "next/script";

<Script
  type="application/ld+json"
  dangerouslySetInnerHTML={{
    __html: JSON.stringify({
      "@context": "https://schema.org",
      "@type": "BlogPosting",
      headline: post.title,
      description: post.description,
      datePublished: post.publishedAt,
      author: { "@type": "Person", name: "Your Name" },
    }),
  }}
/>;

Step 8: Style Blog Content with Tailwind Typography

Also unchanged — MDX content renders as plain, unstyled HTML by default regardless of which remote-MDX package compiled it.

npm install @tailwindcss/typography

/* app/globals.css */
@import "tailwindcss";

@plugin "@tailwindcss/typography";

:root {
  --sh-class: #7aa2f7;
  --sh-sign: #89ddff;
  --sh-string: #9ece6a;
  --sh-keyword: #bb9af7;
  --sh-comment: #acacac;
  --sh-jsxliterals: #7aa2f7;
  --sh-property: #73daca;
  --sh-entity: #e0af68;
  --sh-identifier: #fff;
}

@layer base {
  code:not(pre code) {
    background-color: var(--color-gray-100);
  }

  code:not(pre code) span {
    font-weight: 600;
    color: black !important;
  }

  table {
    display: block;
    max-width: fit-content;
    overflow-x: auto;
    white-space: nowrap;
    text-align: left;
  }
}

Migrating an Existing next-mdx-remote Setup: Checklist

If you already have the original guide's setup running in production, here's the exact diff:

[ ] npm uninstall next-mdx-remote and npm install next-mdx-remote-client@^2 (or @^1 on React 18)
[ ] Remove transpilePackages: ['next-mdx-remote'] from next.config.mjs if present — it's not needed for next-mdx-remote-client
[ ] Change import { MDXRemote } from "next-mdx-remote/rsc" to import { MDXRemote } from "next-mdx-remote-client/rsc"
[ ] Change options={{ mdxOptions: { remarkPlugins: [remarkGfm] } }} to a typed MDXRemoteOptions object (optional, but gets you autocomplete)
[ ] Add an onError component and pass it as a prop — you're no longer required to hand-roll this yourself
[ ] Confirm your route already wraps <MDXRemote /> in <Suspense> — next-mdx-remote's RSC component was also async, so this requirement doesn't actually change
[ ] mdx-components.tsx, lib/posts.ts, your .mdx content files, and your Tailwind Typography setup all need zero changes

For most blogs, this is a genuinely small migration — the package was designed as a drop-in-shaped replacement, not a rewrite.

Frequently Asked Questions

Is next-mdx-remote-client a fork or a completely separate project?

It's a from-scratch package built independently in 2024, in the spirit of @mdx-js/mdx, rather than a literal code fork — but it's positioned and documented as a direct alternative to next-mdx-remote, with a published migration guide for exactly this switch.

Do I need to change my .mdx content files at all?

No. next-mdx-remote-client compiles the same MDX syntax, reads the same frontmatter format, and works with the same custom component map. The migration is entirely in your route and import statements, not your content.

Can I still use next-mdx-remote/utils-style frontmatter parsing without gray-matter?

Yes — use getFrontmatter from next-mdx-remote-client/utils, shown in Step 3. It's isolated in its own subpath specifically so it costs almost nothing to import, and the maintainer notes it works fine even if you're still on plain next-mdx-remote elsewhere in your app.

What's the difference between MDXRemote and evaluate?

MDXRemote is the simpler option when you only need frontmatter and scope data inside the MDX body itself. evaluate is lower-level and returns frontmatter, scope, and exported mod data directly to your page's JSX — reach for it when a byline, reading-time badge, or table-of-contents component outside the MDX needs that data. See Step 6.

Does this work with the Pages Router too?

Yes, but through a completely separate, isolated API — serialize (server-side, in getStaticProps), plus hydrate and MDXClient (client-side) — imported from next-mdx-remote-client/serialize and next-mdx-remote-client/csr rather than /rsc. The App Router and Pages Router code paths don't share internals.

Is next-mdx-remote actually broken right now?

No — HashiCorp archived the repository, meaning it's read-only with no further commits, but the last published version (6.0.0) still installs and runs normally today. Nothing forces an immediate migration. The reason to move is that any future Next.js, React, or @mdx-js/mdx change that breaks compatibility will never get a fix from the original package.

Wrapping Up

The move from next-mdx-remote to next-mdx-remote-client is a narrow, mechanical change for most blogs: swap the package, swap one import path, add an onError handler, and everything else — your content folder, your data layer, your custom components, your Tailwind Typography setup — keeps working exactly as it did. What you get in exchange is a package that's still receiving updates, plus a real error boundary for MDX rendering that the original never shipped.

If you're starting a brand-new Next.js 16 blog today rather than migrating one, just start here directly — there's no reason to build on the archived package first.

Useful Resources

Continue Learning

Free Developer Tools

Meta Tag Generator for Next.js & HTML — generate SEO meta tags, Open Graph tags, Twitter Cards, and JSON-LD instantly for each post.
JSON-LD Generator for Next.js & HTML — generate BlogPosting structured data checked live against Google's Rich Results requirements.

📦 Source Code: View on GitHub

Complete MDX Blog Setup with next-mdx-remote and Next.js 16 (2026 Beginner Guide)

Thu, 30 Jul 2026 19:00:00 +0000

If you've ever tried writing blog posts in plain Markdown inside a Next.js app, you've probably hit a wall pretty fast. Plain Markdown can't render React components, can't handle custom styled code blocks, and definitely can't drop in an interactive widget in the middle of a paragraph.

That's exactly the gap MDX fills — and next-mdx-remote is the easiest way to load MDX content that lives outside your app folder (like a content/blogs directory) and render it as real React.

In this guide, you'll build a complete, production-ready blog setup using next-mdx-remote in Next.js 16 — the same setup powering this very blog. By the end, you'll have:

MDX files stored in a content/blogs folder
A reusable getAllPosts() / getPostBySlug() data layer
Custom-styled MDX components (headings, code blocks, links, tables)
Syntax highlighting with sugar-high
remark-gfm for GitHub-flavored Markdown (tables, strikethrough, task lists)
Dynamic SEO metadata and JSON-LD structured data per post

Why MDXRemote Instead of @next/mdx?

Next.js offers two different ways to work with MDX, and beginners often mix them up.

@next/mdx treats .mdx files as actual pages/routes. You'd create a file like app/blog/my-post/page.mdx and Next.js compiles it into a route at build time. This works, but it means every blog post is a route file living inside app/ — awkward if you want a content/ folder, dynamic [slug] routes, or to pull posts from a CMS/database later.

next-mdx-remote lets you store MDX content anywhere — a content/blogs folder, a database, a CMS — and render it through a single dynamic route like app/blog/[slug]/page.tsx. You read the raw MDX string yourself (usually with the filesystem), then hand it to the <MDXRemote /> component to compile and render.

💡 Tip: If you want a handful of static pages (like a docs page), @next/mdx is simpler. If you're building a blog with many posts and dynamic routing, next-mdx-remote is the better fit — it's what we'll use here.

What We're Building

content/
  blogs/
    hello-world.mdx
    another-post.mdx

lib/
  posts.ts        → reads MDX files, parses frontmatter, sorts posts

app/
  blog/
    [slug]/
      page.tsx              → dynamic route rendering MDXRemote
      opengraph-image.tsx    → auto-generated OG image per post

mdx-components.tsx  → custom styled components used inside MDX

Prerequisites: Next.js 16 (App Router), TypeScript in strict mode, and Tailwind CSS for styling. If your project doesn't already have these, scaffold one with npx create-next-app@latest.

Step 1: Install Dependencies

Run the following command to install everything this setup needs:

npm install next-mdx-remote gray-matter remark-gfm reading-time sugar-high

Here's what each package actually does:

Package	Purpose
`next-mdx-remote`	Compiles and renders MDX strings as React on the server
`gray-matter`	Parses frontmatter (the `---` block at the top of your `.mdx` files)
`remark-gfm`	Adds GitHub-flavored Markdown — tables, strikethrough, task lists
`reading-time`	Calculates estimated reading time from post content
`sugar-high`	Lightweight syntax highlighter for code blocks (no client JS needed)

⚠️ Common Mistake: Don't confuse next-mdx-remote with next-mdx-remote/rsc. The base package is for the Pages Router / client components. For the App Router with Server Components (which is what we want in Next.js 16), you import from next-mdx-remote/rsc instead. We'll use that import throughout this guide.

Step 2: Configure next.config.mjs (Optional)

// next.config.mjs

/** @type {import('next').NextConfig} */
const nextConfig = {
    pageExtensions: ['js', 'jsx', 'md', 'mdx', 'ts', 'tsx'],
    transpilePackages: ['next-mdx-remote'],
}

export default nextConfig

What's happening here:

pageExtensions tells Next.js that .md and .mdx files can also be treated as pages, alongside the usual .ts/.tsx.
transpilePackages: ['next-mdx-remote'] makes sure Next.js properly transpiles the package rather than trying to treat it as pre-built.

Step 3: Create the Content Folder

This is where your actual blog posts will live as plain .mdx files.

content/blogs/hello-world.mdx

---
title: "Hello World: My First MDX Post"
description: "A short example post to test out the MDXRemote setup in Next.js 16."
publishedAt: "2026-07-01"
tags: ["MDX", "Next.js"]
featured: false
---

## Hello World

This is my **first** MDX post rendered with `next-mdx-remote`.

- It supports Markdown
- It supports *React components*
- It even supports tables (thanks to remark-gfm)

| Feature            | Supported |
| ------------------ | --------- |
| Tables             | ✅       |
| Code blocks        | ✅       |
| Custom components  | ✅       |

const greeting: string = "Hello from MDX!";
console.log(greeting);

Understanding the frontmatter block:

The section between the --- lines at the top is called frontmatter. It's plain YAML metadata that describes the post — title, description, publish date, tags — without being part of the rendered content itself. gray-matter (installed earlier) is the library that separates this metadata from the actual MDX body.

⚠️ Common Mistake: Keep your frontmatter field names consistent across every post (title, description, publishedAt, tags, featured). If one file has date and another has publishedAt, your sorting and metadata logic will silently break for that post.

Step 4: Build the Data Layer (lib/posts.ts)

This file is the heart of the whole setup — it reads every .mdx file from disk, parses the frontmatter, and returns clean, typed post objects your pages can use.

// lib/posts.ts
import fs from "fs";
import path from "path";
import matter from "gray-matter";
import readingTime from "reading-time";

const POSTS_PATH = path.join(process.cwd(), "content/blogs");

export type Post = {
  slug: string;
  title: string;
  description: string;
  publishedAt: string;
  updatedAt?: string;
  tags: string[];
  coverImage?: string;
  readingTime: string;
  content: string;
};

export function getAllPosts(): Post[] {
  const files = fs.readdirSync(POSTS_PATH);

  const posts = files.map((file) => {
    const filePath = path.join(POSTS_PATH, file);
    const fileContent = fs.readFileSync(filePath, "utf-8");

    const { data, content } = matter(fileContent);

    const slug = file.replace(/\.mdx$/, "");

    return {
      slug,
      title: data.title,
      description: data.description,
      publishedAt: data.publishedAt,
      tags: data.tags || [],
      coverImage: data.coverImage || "",
      readingTime: readingTime(content).text,
      content,
    };
  });

  return posts.sort(
    (a, b) =>
      new Date(b.publishedAt).getTime() -
      new Date(a.publishedAt).getTime()
  );
}

export function getPostBySlug(slug: string) {
  return getAllPosts().find((post) => post.slug === slug);
}

export function extractFirstImage(content: string) {
  const regex = /!\[.*?\]\((.*?)\)/;
  const match = content.match(regex);
  return match?.[1] || null;
}

Breaking this down line by line:

fs.readdirSync(POSTS_PATH) reads the filenames of every .mdx file inside content/blogs.
matter(fileContent) splits each file into data (the frontmatter object) and content (the raw MDX body below the frontmatter).
slug is derived directly from the filename — hello-world.mdx becomes the slug hello-world, which later becomes the URL /blog/hello-world.
readingTime(content).text automatically calculates something like "3 min read" based on word count — no manual math needed.
Posts are sorted newest-first by comparing publishedAt dates.
extractFirstImage() is a small helper that scans the Markdown content for the first ![alt](url) image — handy for auto-generating Open Graph preview images later.

💡 Tip: Because this uses fs (Node's filesystem module), it can only run on the server — inside Server Components, generateStaticParams, or generateMetadata. Never import lib/posts.ts into a "use client" component.

Step 5: Create Custom MDX Components

By default, MDX renders plain, unstyled HTML tags (<h1>, <p>, <code>, etc). To make your blog actually look good, you override these tags with your own styled versions.

// mdx-components.tsx
import React, { ComponentPropsWithoutRef } from 'react';
import Link from 'next/link';
import { highlight } from 'sugar-high';

type HeadingProps = ComponentPropsWithoutRef<'h1'>;
type ParagraphProps = ComponentPropsWithoutRef<'p'>;
type ListProps = ComponentPropsWithoutRef<'ul'>;
type ListItemProps = ComponentPropsWithoutRef<'li'>;
type AnchorProps = ComponentPropsWithoutRef<'a'>;
type BlockquoteProps = ComponentPropsWithoutRef<'blockquote'>;

const components = {
    h1: (props: HeadingProps) => (
        <h1 className="scroll-m-20 text-4xl font-bold tracking-tight lg:text-5xl" {...props} />
    ),
    h2: (props: HeadingProps) => (
        <h2 className="scroll-m-20 mt-16 pb-2 text-3xl font-semibold tracking-tight" {...props} />
    ),
    h3: (props: HeadingProps) => (
        <h3 className="scroll-m-20 mt-12 text-2xl font-semibold tracking-tight" {...props} />
    ),
    p: (props: ParagraphProps) => (
        <p className="text-gray-800 dark:text-zinc-300" {...props} />
    ),
    ul: (props: ListProps) => (
        <ul className="text-gray-800 dark:text-zinc-300 list-disc pl-5 space-y-1" {...props} />
    ),
    li: (props: ListItemProps) => <li className="pl-1" {...props} />,
    a: ({ href, children, ...props }: AnchorProps) => {
        const className = 'text-blue-500 hover:text-blue-700';

        // Internal links use Next.js's Link for client-side navigation
        if (href?.startsWith('/')) {
            return <Link href={href} className={className} {...props}>{children}</Link>;
        }

        // External links open in a new tab
        return (
            <a href={href} target="_blank" rel="noopener noreferrer" className={className} {...props}>
                {children}
            </a>
        );
    },
    code: ({ children, ...props }: ComponentPropsWithoutRef<'code'>) => {
        const codeHTML = highlight(String(children));
        return <code dangerouslySetInnerHTML={{ __html: codeHTML }} {...props} />;
    },
    blockquote: (props: BlockquoteProps) => (
        <blockquote className="ml-[0.075em] border-l-3 border-green-400 pl-4 text-gray-700" {...props} />
    ),
    em: (props: ComponentPropsWithoutRef<'em'>) => (
        <em className="font-medium" {...props} />
    ),
};

declare global {
    type MDXProvidedComponents = typeof components;
}

export { components };
export function useMDXComponents(): MDXProvidedComponents {
    return components;
}

What's happening here:

Every key in the components object (h1, p, code, etc.) maps directly to that HTML tag name inside your MDX files. Write # My Heading in MDX, and it renders through your custom h1 component automatically.
The code component is the interesting one — instead of plain unstyled text, it runs the code through sugar-high's highlight() function, which returns syntax-highlighted HTML. This gives you colored code blocks with zero client-side JavaScript, since sugar-high runs entirely at render time on the server.
The a component checks whether a link is internal (starts with /) or external. Internal links use Next.js's <Link> for fast client-side navigation; external links get target="_blank" so readers don't lose your site.

⚠️ Common Mistake: Forgetting to style the code component is the #1 reason MDX blogs look broken — code blocks renders with no formatting. Always wire up a syntax highlighter here.

Step 6: Build the Dynamic Blog Route

This is where everything comes together — reading the post, compiling the MDX, and rendering it.

// app/blog/[slug]/page.tsx
import { notFound } from "next/navigation";
import { MDXRemote } from "next-mdx-remote/rsc";
import remarkGfm from "remark-gfm";
import { getAllPosts, getPostBySlug } from "@/lib/posts";
import { components } from "@/mdx-components";

interface BlogPostPageProps {
    params: Promise<{ slug: string }>;
}

// Pre-renders every post at build time (Static Site Generation)
export async function generateStaticParams() {
    const posts = getAllPosts();
    return posts.map((post) => ({ slug: post.slug }));
}

export async function generateMetadata({ params }: BlogPostPageProps) {
    const { slug } = await params;
    const post = getPostBySlug(slug);

    if (!post) return {};

    return {
        title: post.title,
        description: post.description,
    };
}

export default async function BlogPostPage({ params }: BlogPostPageProps) {
    const { slug } = await params;
    const post = getPostBySlug(slug);

    if (!post) {
        notFound();
    }

    return (
        <article className="prose dark:prose-invert mx-auto">
            <h1>{post.title}</h1>

            <MDXRemote
                source={post.content}
                components={components}
                options={{
                    mdxOptions: {
                        remarkPlugins: [remarkGfm],
                    },
                }}
            />
        </article>
    );
}

Understanding each piece:

generateStaticParams() tells Next.js every possible slug value ahead of time, so it can statically generate every blog post page at build time instead of rendering it on every request. This is what makes MDX blogs built this way extremely fast.
generateMetadata() dynamically sets the <title> and meta description per post — critical for SEO, since every post needs its own unique tags rather than a single site-wide default.
notFound() triggers Next.js's built-in 404 page if someone visits a slug that doesn't exist in content/blogs.
<MDXRemote source={...} /> is doing the real work: it takes the raw MDX string (post.content), compiles it into React on the server, and renders it — swapping in your custom components along the way.
remarkPlugins: [remarkGfm] enables GitHub-flavored Markdown syntax inside this specific render call — tables, ~~strikethrough~~, and - [ ] task lists all now work in your MDX files.

💡 Tip: MDXRemote from next-mdx-remote/rsc is an async Server Component. It streams and renders entirely on the server — no MDX compiler code ever ships to the browser, which keeps your client bundle small.

Step 7: Add JSON-LD Structured Data (Optional, but Great for SEO)

To help Google understand each post is a blog article (and potentially show rich snippets), add structured data using Next.js's <Script> component.

// app/blog/[slug]/page.tsx (addition)
import Script from "next/script";

<>
<article>
rest of the code
</article>
<Script
    type="application/ld+json"
    dangerouslySetInnerHTML={{
        __html: JSON.stringify({
            "@context": "https://schema.org",
            "@type": "BlogPosting",
            headline: post.title,
            description: post.description,
            datePublished: post.publishedAt,
            author: { "@type": "Person", name: "Your Name" },
        }),
    }}
/>
</>

This injects a <script type="application/ld+json"> tag containing structured metadata search engines can parse directly — no visible UI change, just better SEO.

Step 8: Update `global.css`

Blog content renders as plain HTML elements with no default styling, so headings, paragraphs, and lists will look unstyled out of the box. The Tailwind Typography plugin fixes this in one line.

Install it:

npm install @tailwindcss/typography

Add the plugin to your global CSS:

/* app/globals.css */
@import "tailwindcss";

@plugin "@tailwindcss/typography";

:root{
  /* your other styles */

  /* add code blocks styling */
  --sh-class: #7aa2f7;
  --sh-sign: #89ddff;
  --sh-string: #9ece6a;
  --sh-keyword: #bb9af7;
  --sh-comment: #acacac;
  --sh-jsxliterals: #7aa2f7;
  --sh-property: #73daca;
  --sh-entity: #e0af68;
  --sh-identifier: #fff;
}

@layer base {
  * {
    @apply border-border outline-ring/50;
  }

  body {
    @apply bg-background text-foreground;
  }

  button:not(:disabled),
  [role="button"]:not(:disabled) {
    cursor: pointer;
  }

  pre::-webkit-scrollbar {
    display: none;
  }

  code:not(pre code) {
    background-color: var(--color-gray-100);
  }

  code:not(pre code) span {
    font-weight: 600;
    color: black !important;
  }

  hr {
    color: var(--color-gray-200);
  }

  /* Remove Safari input shadow on mobile */
  input[type='text'],
  input[type='email'] {
    -webkit-appearance: none;
    -moz-appearance: none;
    appearance: none;
  }

  table {
    display: block;
    max-width: fit-content;
    overflow-x: auto;
    white-space: nowrap;
    text-align: left;
  }
}

Testing Your Setup

Start your dev server:

npm run dev

Then visit:

http://localhost:3000/blog/hello-world

You should see your MDX post fully rendered with styled headings, a working table, and a syntax-highlighted code block.

⚠️ Common Mistake: If you get a "module not found: fs" error, you've likely imported lib/posts.ts inside a Client Component ("use client"). The fs module only works on the server — remove the client directive or move the data fetching to a Server Component / route handler.

Bonus: Dynamic Open Graph Images

// app/blog/[slug]/opengraph-image.tsx
import { ImageResponse } from 'next/og';

export const runtime = 'edge'; // Use Edge Runtime for faster generation
export const alt = 'Blog Post Preview';
export const size = { width: 1200, height: 630 };
export const contentType = 'image/png';

export default async function Image({ params }: { params: Promise<{ slug: string; }> }) {
    const title = (await params).slug.replace(/-/g, ' ');
    
    return new ImageResponse(
        (
            <div
                style={{
                    height: "100%",
                    width: "100%",
                    display: "flex",
                    flexDirection: "column",
                    justifyContent: "space-between",
                    backgroundColor: "#fff",
                    padding: "60px",
                }}
            >

                <div
                    style={{
                        fontSize: 44,
                        display: 'flex',
                        alignItems: 'center',
                        fontWeight: 'bold',
                        gap: '15px'
                    }}
                >
                    <svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 24 24" fill="none" stroke="green" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z" /><path d="M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12" /><path d="M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17" /></svg>
                    <span>Website Name</span>
                </div>

                <div
                    style={{
                        fontSize: 64,
                        fontWeight: 700,
                        lineHeight: 1.1,
                        maxWidth: 900,
                        textTransform: 'capitalize'
                    }}
                >
                    {title}
                </div>

                <div
                    style={{
                        fontSize: 28,
                        opacity: 0.7,
                    }}
                >
                    example.com
                </div>
            </div>
        ),
        { ...size }
    );
}

Frequently Asked Questions

Can I use next-mdx-remote with the Pages Router?

Yes, but you'd import from next-mdx-remote (not the /rsc subpath) and use getStaticProps/getStaticPaths instead of generateStaticParams. The /rsc version shown in this guide is built specifically for the App Router's Server Components.

Do I need @next/mdx if I'm already using MDXRemote?

Not strictly — MDXRemote compiles MDX at runtime regardless of your next.config.mjs setup. But registering .mdx as a page extension avoids editor/tooling quirks and keeps the door open if you ever want static .mdx route files too.

How do I add images inside my MDX posts?

Just use standard Markdown image syntax: ![alt text](/path/to/image.png). If you want Next.js's optimized <Image> component instead, add an img key to your components object in mdx-components.tsx that renders next/image under the hood.

Why is my code block not syntax highlighted?

Double-check that your code component in mdx-components.tsx is running the content through sugar-high's highlight() function. If you copy-pasted code but forgot this override, code blocks fall back to plain unstyled text.

Can I fetch MDX content from a CMS instead of the filesystem?

Yes — that's actually one of the biggest advantages of next-mdx-remote over @next/mdx. Since MDXRemote just needs a raw MDX string, you can fetch that string from Contentful, Sanity, a database, or anywhere else instead of fs.readFileSync. The rest of the setup stays identical.

Wrapping Up

You now have a complete, production-ready MDX blog setup running on Next.js 16 — MDX files stored cleanly in content/blogs, a typed data layer for reading and sorting posts, custom-styled components, GitHub-flavored Markdown support, and per-post SEO metadata.

From here, natural next steps include adding tag-based filtering, a search feature, or auto-generated Open Graph images per post using next/og.

Helpful Resources

If you'd like to keep building out your Next.js stack, these guides pair well with this one:

Try These Free Developer Tools

While you're here, a couple of free tools that pair naturally with a fresh MDX blog setup like this one:

Meta Tag Generator for Next.js & HTML — generate SEO meta tags, Open Graph tags, Twitter Cards, canonical URLs, and JSON-LD structured data instantly. Handy for wiring up per-post metadata like the generateMetadata() function above.
Supabase RLS Policy Generator — if your next project pairs this blog setup with a Supabase backend, generate secure, performance-optimized Row Level Security policies in seconds.
Zod Schema Generator — generate Zod schemas instantly from JSON or TypeScript. Includes smart inference, live validation, React Hook Form, Next.js API Routes, and Server Actions.

📦 Source Code: View on GitHub

Embracing the World of AI as a Gen X'r

Thu, 11 Jun 2026 16:10:26 +0000

Embracing the World of AI as a Gen X’r

is my ongoing chronicle of what happens when someone who grew up on mixtapes, arcades, and a 14.4k dial-up modem finally admits that AI isn’t a fad — it’s the next evolution of the tech we’ve been tinkering with since the days of FrontPage and floppy disks.

This series is part nostalgia tour, part mid‑career reboot, part reminder that Gen X has always adapted, even when we pretended we weren’t paying attention. If I want to keep moving forward in tech, I can’t keep dodging AI — I have to learn it, experiment with it, and figure out how it fits into the world I’ve been building since my introduction to MS-DOS and “Hello, World.” These posts capture that journey: the curiosity, the skepticism, the humor, and the quiet determination to stay in the game rather than age out of it.

Embracing the Wonderful World of AI as a Gen X'r

My blog series 'Embracing the World of AI'

Mon, 25 May 2026 23:02:55 +0000

My new blog series 'Embracing the World of AI (as a Gen Xer) is now up on my website. Read all about how I FINALLY came to realize that AI is our friend!

https://bit.ly/genx-meets-ai

I Looked at the Best Programming Blogs for Python Developers — Here’s What Actually Stands Out

Tue, 05 May 2026 05:46:29 +0000

There’s no shortage of Python content online. The problem isn’t finding blogs. It’s figuring out which ones are actually worth following over time.

Some sites are great for deep tutorials but don’t update often. Others publish frequently but vary in quality. A few manage to strike a balance, and those are usually the ones developers keep coming back to.

While going through different programming blogs for Python developers, one thing became clear:

Not all “Python blogs” serve the same purpose. Some are standalone learning resources. Others are part of larger developer platforms that publish Python content alongside other topics.

If you’re trying to decide what to follow in 2026, it helps to look at both.

Quick Answer

Some of the best programming blogs for Python developers include In Plain English (and Python in Plain English), Real Python, DEV Community, Stackademic, Talk Python, PyImageSearch, and Hashnode.

In Plain English stands out for its combination of consistent publishing and a dedicated Python publication
Real Python is one of the most reliable sources for in-depth tutorials
DEV Community is useful for practical, real-world Python content
Stackademic offers structured, educational articles
Talk Python helps you stay connected to the broader Python ecosystem
PyImageSearch is excellent for niche topics like computer vision
Hashnode brings together independent developer blogs

Each of these is useful for a slightly different reason.

What Makes a Python Blog Worth Following?

When you’re not just reading occasionally but actually following a blog, a few things start to matter more:

Consistency:
Does it publish regularly enough to stay relevant?
Clarity:
Are concepts explained in a way that’s easy to follow?
Depth:
Does it go beyond surface-level explanations?
Relevance:
Does it reflect what developers are actually building?
Usefulness over time:
Is it something you’ll keep coming back to?

The blogs below stood out because they perform well across at least some of these areas.

Best Programming Blogs for Python Developers (Curated List)

Blog / Platform	Best For	Content Style	Why It Stands Out
In Plain English	Consistent Python content + distribution	Accessible tutorials	Combines ecosystem + dedicated Python publication
Real Python	Deep learning	Structured tutorials	High-quality, in-depth content
DEV Community (Python)	Practical insights	Community-driven	Real-world use cases and discussions
Stackademic	Structured learning	Educational guides	Clear progression and explanations
Talk Python	Ecosystem awareness	Blog + podcast	Industry trends and updates
PyImageSearch	Niche depth	Specialized tutorials	Strong focus on computer vision
Hashnode (Python blogs)	Diverse perspectives	Independent blogs	Wide range of voices

1. In Plain English — A Consistent Python Content Ecosystem (Plus a Dedicated Python Blog)

If you’re looking for something to follow consistently, In Plain English is one of the more dependable options.

What makes it different is that it operates as a broader developer content ecosystem rather than a single blog.

On one level, it publishes Python-related articles directly on its main platform. These include:

tutorials
practical guides
tooling and framework walkthroughs

Alongside that, it also runs a dedicated publication: Python in Plain English.

That combination matters more than it might seem.

the main platform gives you broader exposure to Python alongside adjacent topics like AI and cloud
the Python-focused publication gives you a more concentrated stream of Python-specific content

In practice, this means you can:

follow only Python-focused articles
or stay connected to how Python fits into the wider development ecosystem

Another thing that stands out is consistency.

Because content comes from a large contributor base, there is a steady flow of new articles. That makes it easier to keep up with:

new libraries and tools
practical implementation ideas
evolving best practices

Compared to standalone Python blogs, it feels less like checking in occasionally and more like having a continuous stream of relevant content.

That mix of frequency, accessibility, and topic coverage is what puts it at the top.

2. Real Python — Still the Gold Standard for In-Depth Learning

If there’s one name that shows up in almost every list of Python blogs, it’s Real Python.

And for good reason.

This is one of the few platforms that consistently delivers:

detailed tutorials
structured learning paths
well-explained concepts

The difference is noticeable when you read through their content.

articles are carefully organized
examples are clear and practical
explanations go beyond just showing code

It’s especially useful when:

you’re learning something new
you want to understand a concept properly
you need a reliable reference

Compared to higher-frequency platforms, Real Python publishes less often, but the depth tends to make up for it.

3. DEV Community (Python Tag) — Practical, Real-World Python Content

DEV Community works differently from most traditional blogs.

It’s not a single editorial voice. It’s a platform where developers share what they’re working on.

That changes the kind of content you get.

quick tutorials
debugging experiences
lessons learned from real projects
comparisons between tools and approaches

If you’re trying to understand how Python is being used in practice, this is one of the better places to look.

Compared to more curated blogs, DEV Community is more immediate.

content reflects current problems
discussions add extra context
feedback helps refine ideas

It’s particularly useful for staying grounded in real-world use cases.

4. Stackademic — Clear, Structured Python Tutorials

Stackademic leans more toward structured, educational content.

The difference shows in how tutorials are written.

concepts are introduced step by step
explanations are given proper space
articles tend to build on ideas rather than jump straight to results

For Python developers, this makes it useful when:

you want a more guided learning experience
you prefer clarity over speed
you are trying to connect different concepts

Compared to DEV Community, it feels more curated and more consistent in tone.

5. Talk Python — Staying Connected to the Python Ecosystem

Talk Python is slightly different from the others because it combines a blog with a podcast.

That gives it a broader perspective.

Instead of focusing only on tutorials, it also covers:

industry trends
new tools and libraries
insights from people in the Python community

It’s a good way to stay updated on what’s happening beyond just code.

If you want to understand where Python is heading, not just how to use it, this is worth following.

6. PyImageSearch — Deep Dive into Computer Vision

If your interests lean toward computer vision, PyImageSearch is one of the most useful niche Python blogs.

The content is focused and technical.

image processing
deep learning
OpenCV-based tutorials

What stands out is the depth within that niche.

Instead of covering everything, it goes deep into a specific area, which makes it especially valuable if that’s relevant to your work.

7. Hashnode (Python Blogs) — A Network of Independent Voices

Hashnode is not a single Python blog, but a platform where developers run their own blogs.

That leads to a different experience.

a mix of beginner and advanced content
different perspectives and approaches
a wide range of topics

Over time, you can find individual writers whose content you trust and follow them directly.

It’s less curated than some of the other options, but it gives you access to a broader set of viewpoints.

How to Get the Most Value From These Python Blogs

Following multiple blogs only works if you use them intentionally.

A simple way to approach it:

use Real Python or Stackademic for deeper learning
use DEV Community for practical insights
use Talk Python for ecosystem awareness
use In Plain English for a steady flow across topics

This way, you’re not relying on a single source to do everything.

Frequently Asked Questions (FAQ)

What are the best programming blogs for Python developers?

Some of the best include In Plain English, Real Python, DEV Community, Stackademic, Talk Python, PyImageSearch, and Hashnode.

Which Python blog is best for beginners?

Real Python and Stackademic are strong options because they focus on structured, easy-to-follow tutorials.

Are community platforms like DEV Community useful for Python learning?

Yes. They provide real-world examples, discussions, and practical insights that complement more structured learning resources.

Should I follow multiple Python blogs?

Yes. Different blogs serve different purposes, and combining them gives you a more complete view of the ecosystem.

Is it better to follow niche Python blogs or general developer platforms?

Both are useful. Niche blogs provide depth, while broader platforms provide variety and context.

Final Thoughts

After spending time with these, the biggest difference wasn’t just in content quality, but in how each one fits into your routine.

Some are the kind you open when you’re trying to learn something properly. Others are easier to check in on regularly and pick up ideas as you go.

That makes a difference in what you actually end up using.

Instead of trying to find the single best Python blog, it’s more useful to figure out which combination you’ll realistically keep coming back to.

Building This Blog: A Modern Next.js Blog with Markdown

Tue, 21 Apr 2026 21:12:52 +0000

Building This Blog: an MDX‑powered Next.js blog

This blog is a small, opinionated setup for writing long‑form content that feels good to read and fun to build on.

Under the hood it uses static generation, MDX, and a theme‑aware UI that works in both light and dark modes.

Everything after the frontmatter is pure MDX. Components like Callout, Steps, architecture diagrams, flows, and charts are all React components rendered directly in the post body.

Stack I ended up with

I wanted something fast, simple, and easy to reason about over years—not weeks.

The site is a static App Router app. Routes like `/blog/[slug]`, `/til/[slug]`, `/technical-terms/[slug]` are statically generated at build time.


TypeScript keeps the content layer and components honest. Tailwind + CSS variables handle layout and theming.


All long‑form content lives in the repo inside content/, written as `.md` or `.mdx` files with frontmatter.


Views, upvotes, and UTM events are stored in Supabase and surfaced through a custom analytics dashboard.

How content works

All posts are simple files in the repo—no CMS required.

---
title: "Your Post Title"
description: "Post description"
date: "2024-01-20"
author: "Your Name"
tags: ["tag1", "tag2"]
category: "Category"
featured: true
---

Your content here...

Markdown (.md) posts go through a Remark pipeline and are rendered as HTML.
MDX (.mdx) posts are compiled at runtime in the page using next-mdx-remote/rsc, with a shared component map.

For posts that need diagrams, flows, or charts, I use .mdx and drop in components like ArchitectureCard, FlowStep, and DemoBarChart.

Authoring flow

Add a new `.md` or `.mdx` file to content/blog/ with frontmatter for SEO, tags, and images.


Run npm run dev and iterate on copy, diagrams, and layout until the post feels polished.


Push to the main branch. The build step generates static HTML for every route and updates search data + OG images.

Architecture of the blog

At a high level, the blog is just three pieces: browser, Next.js, and Supabase.

Readers get fully rendered HTML from the CDN, with minimal JavaScript on top for upvotes, analytics, and small interactions.


Next.js statically generates pages for blog posts, TIL entries, technical terms, and lists. It also exposes a few API routes for analytics.


Supabase stores per‑page views, upvotes, and UTM events that feed the analytics dashboard and charts.

Request–response flow for a page view

Here’s how a single blog page view flows through the system.

The CDN serves a pre‑rendered HTML page that was generated at build time.


Next.js hydrates the page; components like the upvote button, custom cursor, and view counter start working.


A lightweight request records the view / upvote in Supabase without blocking the reader.


Aggregated stats are used to power Recharts visualizations on the analytics page.

Visualizing traffic with charts

The same Recharts setup used in the analytics dashboard is available inside MDX posts.

Charts are plain React components exposed to MDX. They respect the global theme and use the same accent palette as the rest of the site.

Performance before and after

Static export plus small tweaks around assets made a noticeable difference in user‑facing numbers.

Why this setup works for me

Files as the source of truth – I can write posts in a text editor, version them in git, and refactor them like any other code.
Static by default – Most pages are static HTML, which is great for speed and reliability.
MDX when I need power – Architecture diagrams, flows, and charts are just components; I only reach for them when a post really needs them.
Theme‑aware UI – Components use the same CSS variables as the rest of the app, so they look good in both light and dark modes.

If you want to explore the implementation details, the full source code is on GitHub. You could clone it, point it at your own content folder, and have a similar blog running in minutes.

Why Engineers Must Become Multipliers in the AI-Era

Wed, 19 Nov 2025 11:44:42 +0000

Why Engineers Must Become Multipliers in the AI Era

The Shift in What Makes a Good Engineer

Ten years ago, being an engineer was mostly about knowing HTML, CSS, JavaScript, and one frontend framework. Today, the expectations have changed. It's no longer enough to just write code companies now want engineers who can think, communicate, solve real problems, and create impact beyond their own tasks.

How Software Development Has Changed

Better Tools, Faster Prototyping

Modern tools allow even non-technical people to build simple prototypes. But real products still require strong fundamentals: security, scalability, and maintainability.

AI-Assisted Engineering

AI accelerates development, but engineers still need to understand what to build, why to build it, and how to build it correctly.

Engineers Now Own More Than Just the “How”

In many startups, engineers lead their own projects and make product decisions. This shift means engineers must understand the problem, own the solution, and deliver impact — not just follow requirements.

What Is an Engineering Multiplier?

An Engineering Multiplier is someone who increases the productivity and effectiveness of everyone around them. They don’t just code — they elevate the entire team.

1. Improving Team Efficiency

They remove friction, simplify processes, and help others move faster.

2. Sharing Knowledge

They document, mentor, and help teammates level up.

3. Raising the Quality Bar

High-quality work naturally pushes others toward better standards.

4. Helping Teams Make Better Decisions

They understand trade-offs and connect engineering choices to business goals.

5. Empowering Others

They don’t just solve problems — they help others learn how to solve them too.

What Job Requirements Actually Mean Today

Long lists of technologies in job posts don’t mean you must know everything. Companies want people who can learn quickly, solve problems, communicate well, and adapt. Essentially — they want multipliers.

What Multiplier Skills Look Like in Practice

Multipliers are resourceful. They combine existing knowledge with problem-solving and collaboration. They know how to learn anything they need by leveraging experience, AI tools, and people around them.

A Simple Analogy: Building a House

When you hire a contractor, you don’t count how many nails they hammer. You care about quality, timelines, and communication. Great engineers work the same way — they focus on outcomes and smooth collaboration.

The Trend of Flatter Organizations

Many companies are reducing layers of management. Engineers are expected to be more autonomous and take more ownership. Multipliers thrive in this environment.

Final Thoughts

AI isn’t replacing engineers — it’s redefining what great engineering looks like. The best engineers today don’t just code. They communicate, prioritize, collaborate, and multiply the impact of their team. The future belongs to Engineering Multipliers.

Read the full blog here: blog

Some Ranting on Dev.to and Opinion on UI Design

Mon, 04 Aug 2025 19:43:11 +0000

Overview

Each platform strives to provide its best and each has its pros and cons. Some are simple technical issues - like the Markdown editor of CoderLegion, some are serious design flaws (like there is no way to manage brushes in Affinity Photo).

Today I was going to comb my thoughts and write something on Dev.to and was shocked so see this.

This ugly new feature is driving me mad.

It's one of the things I don't like about Discord/Slack. The interface is so clustered with irrelevant things or buttons that I rarely click on or need. And there are too many colors.

Now Dev.to is completely ruining the used-to-be quiet and focused writing experience. Just look at the screenshot below:

It's honestly so annoying I can't bear staying on this site any second longer. What's worse, because of this total distraction, I almost forgot what I was about to write.

Alternatives

I would love to officially moving to CoderLegion for canonical Dev Logs, but the image uploading experience is also not smooth. So that's a dilemma.

We have the official Methodox Blog on WordPress. For those who aren't familiar with its content management system - it requires uploading images to the blog server for every single thing you display (or else use plugins) and is really inconvenient if one just want to share quick screenshots.

Medium is actually great writing experience, but its design feels more suited for literature work than for tech.

Ideal Scenario

Here I propose a concept "QuietSpace" for distraction-free blogging.

Key ideas:

Medium style editing interface
Dev.to style Markdown and easy image uploading through dropping and pasting, single button Preview
CDN for blog contents
GitHub style support for video and YouTube embedding.

Key formatting elements:

Fully support tables (a issue in both CoderLegion and Medium)
Fully support images gifs and videos (through CDN link) (an issue in Dev.to)

Web editor, optional desktop editor. No dedicated subdomain: url path for user. No ads, central explore and save articles. May even be paid writing experience at $5 per month. Easy sharing, simple commenting.

Used for: DevLog.

Derivation: dedicated blog-style web hosting, like the simplest form of Word Press.

Summary

There are many blogging and posting platforms and each has distinct features. As a developer we seek a balance between publicity, platform friendliness and technical satisfaction. I think the best platform has to be customized for custom needs. While generic customizable frameworks exist, the customization process right now still take too much tweaking. Will AI solve this problem? I doubt it, as I see missing pieces in basic infrastructure that's not easily addressed with smart agents.

Follow Up

I was writing this post bearing in mind I have to suffer the new UI update of Dev.to - life felt truly like a compromise.

However, the dev team addressed the issue within an hour! I didn't even expect them to notice my post. Salute To Dev.To Dev Team! See discussion on the post on Dev.to.

Coder Legion - Recent posts tagged blog

Top Ahrefs & Semrush Alternatives for Small Bloggers on a Budget

Hermes: Autonomous AI Agents for Career Growth and Opportunity Exploration

How to Streamline Your Blogging Workflow with Automation Tools

How to Find SEO Issues Before Publishing a Blog Post

Should Your Business Have a Blog? The Honest Answer

What a Blog Actually Does, When It Works

Why It Fails for a Lot of Businesses

The Real Question: Does Your Business Have Genuine Search Demand

What "Doing It Well" Actually Requires

What to Do Instead, If a Blog Genuinely Isn't the Right Fit

Frequently Asked Questions

next-mdx-remote-client Guide for Next.js 16 (2026)

Why next-mdx-remote-client Instead of next-mdx-remote?

A Quick Word on Security

Prerequisites

Step 1: Install Dependencies

Step 2: Content Folder and Frontmatter (Unchanged)

Step 3: Build the Data Layer

Step 4: Create Custom MDX Components

Step 5: Build the Dynamic Blog Route

Step 6: Want Frontmatter and Scope Inside JSX? Use evaluate Instead

Step 7: Add JSON-LD Structured Data (Optional, but Great for SEO)

Step 8: Style Blog Content with Tailwind Typography

Migrating an Existing next-mdx-remote Setup: Checklist

Frequently Asked Questions

Is next-mdx-remote-client a fork or a completely separate project?

Do I need to change my .mdx content files at all?

Can I still use next-mdx-remote/utils-style frontmatter parsing without gray-matter?

What's the difference between MDXRemote and evaluate?

Does this work with the Pages Router too?

Is next-mdx-remote actually broken right now?

Wrapping Up

Useful Resources

Continue Learning

Free Developer Tools

Complete MDX Blog Setup with next-mdx-remote and Next.js 16 (2026 Beginner Guide)

Why MDXRemote Instead of @next/mdx?

What We're Building

Step 1: Install Dependencies

Step 2: Configure next.config.mjs (Optional)

Step 3: Create the Content Folder

Step 4: Build the Data Layer (lib/posts.ts)

Step 5: Create Custom MDX Components

Step 6: Build the Dynamic Blog Route

Step 7: Add JSON-LD Structured Data (Optional, but Great for SEO)

Step 8: Update global.css

Testing Your Setup

Bonus: Dynamic Open Graph Images

Frequently Asked Questions

Can I use next-mdx-remote with the Pages Router?

Do I need @next/mdx if I'm already using MDXRemote?

How do I add images inside my MDX posts?

Why is my code block not syntax highlighted?

Can I fetch MDX content from a CMS instead of the filesystem?

Wrapping Up

Helpful Resources

Related Guides

Try These Free Developer Tools

Embracing the World of AI as a Gen X'r

Embracing the World of AI as a Gen X’r

My blog series 'Embracing the World of AI'

I Looked at the Best Programming Blogs for Python Developers — Here’s What Actually Stands Out

Quick Answer

What Makes a Python Blog Worth Following?

Best Programming Blogs for Python Developers (Curated List)

1. In Plain English — A Consistent Python Content Ecosystem (Plus a Dedicated Python Blog)

2. Real Python — Still the Gold Standard for In-Depth Learning

3. DEV Community (Python Tag) — Practical, Real-World Python Content

4. Stackademic — Clear, Structured Python Tutorials

5. Talk Python — Staying Connected to the Python Ecosystem

6. PyImageSearch — Deep Dive into Computer Vision

7. Hashnode (Python Blogs) — A Network of Independent Voices

How to Get the Most Value From These Python Blogs

Frequently Asked Questions (FAQ)

What are the best programming blogs for Python developers?

Which Python blog is best for beginners?

Are community platforms like DEV Community useful for Python learning?

Should I follow multiple Python blogs?

Is it better to follow niche Python blogs or general developer platforms?

Step 6: Want Frontmatter and Scope Inside JSX? Use `evaluate` Instead

Step 8: Update `global.css`