Respondra Blog

Most angel investors have no idea if they're actually making money. They know Company X got acquired and Company Y shut down, but ask them for their portfolio IRR and you'll get a blank stare. The problem isn't just math. It's that most angels think tracking performance means adding another row to a spreadsheet when they write a check.

But tracking angel investment performance properly starts long before you transfer money. The real insights come from understanding not just what you invested in, but what you passed on and why. Without that context, you're not tracking performance. You're just keeping receipts.

Why Spreadsheets Fail at Angel Performance Tracking

Here's what most angels do: create a spreadsheet with columns for company name, investment amount, date, and maybe current valuation. They update it occasionally when something big happens. This approach misses 90% of what actually matters for understanding your investment performance.

Real performance tracking requires understanding:

• Why you made each investment decision

• What deals you evaluated but passed on (and why)

• How your due diligence process affects outcomes

• Which founder characteristics predict success

• How market timing impacts your returns

• Whether your follow-on strategy is working

A spreadsheet can't capture the decision-making context that determines whether you're getting better as an investor over time. It just tracks the outcomes of decisions you've already made.

The Performance Data You're Not Tracking

Decision Quality vs. Outcome Quality You invested in Company A because of strong traction metrics and passed on Company B because the market seemed too small. If Company A fails and Company B succeeds, was your decision-making wrong? Maybe. Or maybe you made the right decision with the information available and got unlucky. Without tracking your reasoning, you can't tell the difference.

Pattern Recognition Across Deals Are founders with previous startup experience more likely to succeed in your portfolio? Do enterprise software companies perform better than consumer apps? Which industries in your local market have the highest failure rates? You can't answer these questions without systematic data on every deal you've evaluated.

Due Diligence Effectiveness How much time do you spend on due diligence for successful vs. failed investments? Are there specific red flags you consistently miss? Which due diligence questions actually predict success? Most angels do the same due diligence process for every deal without learning what works.

Follow-On Performance When you double down on a company, do those follow-on investments perform better or worse than your initial investments? Are you good at identifying which companies deserve more capital? Most angels make follow-on decisions emotionally without data on their track record.

Market Timing Impact Did companies you invested in during 2021 perform differently than 2023 investments? How does the broader funding environment affect your portfolio performance? Understanding cyclical patterns helps you adjust strategy over time.

What Proper Angel Performance Tracking Looks Like

Real performance tracking starts the moment you see a pitch deck, not when you write a check. Here's what you should be capturing:

Deal Flow Analysis

• Every company you evaluate (not just investments)

• Source of the deal (referral, event, cold outreach)

• Stage and sector of each opportunity

• Why you passed on deals you didn't invest in

• How many deals you see vs. how many you invest in

Investment Decision Documentation

• Specific reasons for each investment (traction, team, market, etc.)

• Due diligence time spent and key findings

• Investment thesis and expected outcomes

• Risk factors you identified upfront

• Follow-on plans and triggers

Ongoing Performance Monitoring

• Regular updates on key metrics (not just valuations)

• Milestone tracking against initial projections

• Management team changes and effectiveness

• Market developments affecting each company

• Your involvement level and value-add activities

Outcome Analysis

• Actual returns vs. projected returns

• Time to exit vs. expectations

• Correlation between initial thesis and final outcome

• Lessons learned from both successes and failures

• Decision-making improvements over time

The Real Performance Metrics That Matter

Portfolio Construction Metrics:

• Diversification across sectors, stages, and geographies

• Average investment size vs. portfolio allocation strategy

• Follow-on investment ratio and performance

• Deal flow conversion rates by source

Decision Quality Metrics:

• Due diligence time vs. investment outcomes

• Accuracy of initial market size assessments

• Team evaluation effectiveness

• Competitive analysis quality

Return Analysis:

• IRR calculation methodology for illiquid investments

• Cash-on-cash multiples by vintage year

• Unrealized vs. realized return tracking

• Comparison to relevant benchmarks (not just public markets)

Learning Velocity:

• How your deal evaluation is improving over time

• Which types of investments you're getting better at identifying

• Whether your network is delivering higher quality deal flow

• How your post-investment value-add affects outcomes

Building a System That Actually Works

Tracking this level of detail manually is impossible. You need a system that captures the entire investment lifecycle, not just the moment you write a check.

In Respondra, you can manage the complete flow: from initial due diligence analysis through ongoing tracking, founder updates, equity conversions, and comprehensive analytics that tie everything together. Instead of maintaining separate spreadsheets for deal flow, investments, and performance, everything connects to give you actual insights into your investing effectiveness.

The platform tracks not just what you invested in, but what you passed on and why. It maintains the complete history of your decision-making process so you can identify patterns and improve over time. When a company in your portfolio exits, you can look back at your original analysis and understand what you got right or wrong.

This is how you build systematic improvement as an angel investor rather than just hoping your next bet works out.

The Compound Effect of Better Tracking

Angels who track performance properly don't just know their returns. They systematically improve their decision-making over time. They identify which deal sources deliver the best opportunities. They recognize their own biases and blind spots. They get better at due diligence because they know which questions actually matter.

Most importantly, they can articulate their investment strategy beyond "I know it when I see it." This makes them more attractive to entrepreneurs, helps them get invited into better deals, and enables them to syndicate investments with other high-quality angels.

The difference between good angels and great angels isn't luck. It's systematic learning from every decision they make. But you can't learn systematically without tracking systematically.

Are You Actually Tracking Performance?

If you can't calculate your portfolio IRR, explain your investment thesis evolution, or identify patterns in your successful investments, you're not tracking performance. You're just keeping a list of companies you've written checks to.

Real performance tracking starts with your first deal evaluation and continues through every exit. It requires capturing not just outcomes, but the decision-making process that led to those outcomes. It means being honest about what you don't know and systematic about learning from what you do.

Your next great investment isn't going to come from lucky guessing. It's going to come from understanding what's worked before and why. But first, you need to actually track what's working.

Somewhere in your inbox right now is a founder update that contains the early warning signs of your next big win or catastrophic loss. But you'll never know because you closed it after reading once and never followed up. If the founder is doing great, that's amazing, but if they are drowning you missed an opportunity to provide value and course correct.

Here's the uncomfortable truth: most angels treat founder updates like company newsletters. Read once, feel informed, move on. But these aren't newsletters. They're business intelligence reports from companies you own equity in, written by founders who could use your help.

Why We Treat Updates Like One-Way Newsletters (But They're Not)

The problem starts with how founder updates feel. They arrive monthly in your inbox, formatted like marketing emails, full of metrics and milestone celebrations. It's easy to consume them passively, like reading TechCrunch.

But founder updates aren't journalism. They're performance reports on your investments, written by entrepreneurs who are often struggling with problems you've solved before. When you read "we're exploring new customer acquisition channels" and just nod along, you've missed a chance to introduce them to your network. When they mention "fundraising challenges," that's not just information. It's a cry for help.

The best angels understand that founder updates are actually two-way communication disguised as one-way broadcasts. Every update contains implicit asks for guidance, connections, and support. Most angels never respond because they don't see the subtext.

The Signals Most Angels Miss

Let's decode what founders are really saying in their updates:

"We're pivoting our go-to-market strategy" Translation: Our current approach isn't working and we're not sure what to try next. Your move: Share what's worked for similar companies in your portfolio.

"We're excited about new partnership opportunities" Translation: We need strategic partnerships but don't know how to structure them. Your move: Introduce them to potential partners or someone who's done successful partnerships.

"Fundraising is taking longer than expected" Translation: We're struggling to raise and might run out of money. Your move: Make introductions to other investors or help refine their pitch.

"Team is scaling well, hired three new engineers" Translation: We're growing fast and might need advice on management and culture. Your move: Connect them with other founders who've scaled teams successfully.

"Revenue is up 40% month-over-month" Translation: We're crushing it and this might be a good follow-on opportunity. Your move: Consider increasing your investment or helping them raise a larger round.

The founders who write these updates aren't just reporting metrics. They're sending signals about where they need help. But if you're not responding, you're missing opportunities to add value and strengthen your position.

How to Systematically Track and Respond to Updates

The angels who get the most value from founder updates don't just read them. They track patterns and respond strategically. Here's how to build a system:

Track Key Metrics Over Time

Don't just read the current month's numbers. Look for trends:

• Revenue growth trajectory (accelerating or slowing?)

• Burn rate changes (are they becoming more or less efficient?)

• Team size evolution (scaling too fast or too slow?)

• Customer acquisition patterns (finding product-market fit?)

Identify the Real Asks

Every founder update contains explicit asks ("we're looking for introductions to enterprise customers") and implicit ones ("our biggest challenge this month was..."). Keep a running list of what each founder needs.

Set Response Triggers

Decide when you'll reach out:

• When they mention specific challenges in your area of expertise

• When metrics show concerning trends (declining growth, rising burn)

• When they hit major milestones (good time for follow-on investment)

• When they mention fundraising (help with intros or due diligence)

Maintain Update History

You can't spot patterns if you don't remember what they said last month. Keep a simple record of key metrics and asks from each update.

When to Provide Value vs. When to Stay Quiet

Not every founder update requires a response. Here's when to engage and when to let them work:

Respond when:

• They're facing a problem you've solved before

• You have specific, actionable advice (not just encouragement)

• You can make a valuable introduction

• They're showing early signs of trouble you've seen in other companies

• They're hitting milestones that suggest follow-on opportunity

Stay quiet when:

• Everything is going well and they don't need help

• Your advice would be generic ("keep pushing" isn't helpful)

• They're in a space you don't understand well enough to add value

• They're dealing with internal team issues (unless specifically asked)

The goal isn't to respond to every update. It's to respond when you can actually help.

Using Updates to Inform Follow-On Investments

Founder updates are the best early indicator of which companies in your portfolio deserve more investment. Here's what to watch for:

Green flags for follow-on investment:

• Consistent revenue growth with improving unit economics

• Expanding market opportunity with clear path to scale

• Strong team execution on previous milestones

• Growing demand that's outpacing their ability to serve customers

• Strategic partnerships that create competitive moats

Red flags to watch:

• Revenue growth slowing despite increased spending

• Frequent strategy pivots without clear learning

• Team turnover in key positions

• Burning through cash faster than hitting milestones

• Market adoption slower than projected

The angels who consistently find the best follow-on opportunities aren't necessarily the ones with the best deal flow. They're the ones who stay closest to their existing portfolio companies through regular update engagement.

Building a System That Actually Works

If you're managing your portfolio in Respondra, you can forward founder updates directly to the platform. The AI extracts key metrics and identifies specific asks, so you can see exactly where founders might need help without manually tracking everything.

Instead of letting updates pile up in your inbox, you get:

• Automatic tracking of revenue, burn rate, and team size over time

• AI-identified asks and challenges that match your expertise

• Pattern recognition across your portfolio (which companies are trending up/down)

• Reminders to follow up when founders mention specific needs

This turns founder updates from passive reading into active portfolio management. You're not just staying informed. You're staying engaged.

The Real Opportunity

Most angels read founder updates like they're consuming content. But these updates represent your best chance to add value beyond capital. When you respond thoughtfully to founder challenges, you strengthen your relationship with entrepreneurs who will start more companies, recommend you to other founders, and think of you first for their next round.

The angels who treat founder updates as business intelligence rather than newsletters are the ones who get invited into the best deals. They're the ones founders call when they need advice, introductions, or follow-on investment.

Stop treating these updates like spam. Start treating them like the portfolio management tool they actually are.

Your portfolio companies are telling you exactly what they need help with every month. The question is: are you listening?

Let's be honest. When that founder sends you their pitch deck, your first instinct in 2025 is probably to throw it into whatever AI tool you have open. ChatGPT, Claude, maybe Grok if you're feeling adventurous. I get it. AI can write code, create presentations, even help with legal documents. Surely it can tell you if this startup is worth your investment, right?

I discovered this firsthand when building Respondra's pitch analysis feature. One of our users ran nearly 100 pitch decks through our system, and the patterns that emerged showed me exactly why general-purpose AI models are dangerously bad at investment due diligence. Not because they're not smart enough, but because they're trained for the wrong job entirely.

Why Generic AI Models Miss What Actually Matters

Here's the fundamental problem: ChatGPT was trained to be helpful, harmless, and honest about everything from poetry to pizza recipes. It has no idea that a 200% year-over-year growth claim in slide 7 should be cross-referenced with the financial projections in slide 12, or that a "huge TAM" without serviceable addressable market details is a red flag.

When you paste a pitch deck into a generic AI model, you typically get back something that sounds impressive but misses the core investment fundamentals:

What Generic AI Gives You:

• "This looks like an innovative solution to a real problem"

• "The team has relevant experience"

• "The market opportunity appears significant"

What You Actually Need:

• Specific unit economics analysis

• Competitive differentiation assessment

• Revenue model validation

• Team experience gaps

• Market sizing methodology review

The difference isn't just nuance. It's the difference between useful analysis and expensive mistakes.

The Real Problem: Every Angel Investor Is Different

Even if generic AI models understood investment fundamentals perfectly, they'd still fail at the most crucial part: every angel investor cares about different things.

Some angels prioritize traction above everything else. Others focus heavily on team experience. Some won't touch anything without clear competitive moats. Generic AI treats all these criteria equally, which means it's optimized for no one.

This is where specialized AI actually becomes useful. In Respondra's pitch analysis feature, angels can set their own metric weightings. Care more about traction than team? Adjust the sliders. Only invest in massive markets? Weight that category higher. The AI analysis adapts to what you actually care about, not what some generic model thinks you should care about.

What Proper AI-Assisted Due Diligence Looks Like

When one of our users analyzed nearly 100 pitch decks, we started seeing patterns that no generic AI would catch. Here's what specialized investment AI actually does:

Financial Reality Checks

Instead of accepting revenue projections at face value, proper investment AI asks the right questions:

• Are the unit economics realistic given the business model?

• Do the growth assumptions align with comparable companies?

• Is the burn rate sustainable given the funding ask?

Market Analysis That Goes Beyond Buzzwords

Rather than just identifying that "AI is a big market," investment-focused AI digs into:

• Total addressable market calculation methodology

• Serviceable addressable market sizing

• Go-to-market strategy feasibility

• Competitive landscape analysis

Team Assessment Beyond LinkedIn Headlines

Instead of just noting that founders have "relevant experience," specialized AI evaluates:

• Specific industry knowledge gaps

• Previous startup experience outcomes

• Team composition completeness

• Operational scaling capabilities

The Due Diligence Questions You Should Be Asking

The screenshot above shows how proper AI analysis generates specific, actionable questions rather than generic observations. Instead of "the team looks good," you get:

• "What is the team's experience in scaling a business?"

• "What are the key hires needed to support future growth?"

• "How does the team differentiate itself from competitors?"

These aren't questions a founder can deflect with buzzwords. They require substantive answers that reveal whether the opportunity is real or just well-presented.

Implementation: Building AI That Actually Helps

From a technical perspective, the difference between useful and useless AI analysis comes down to three key factors:

1. Training Data Specificity

Generic models are trained on everything. Investment AI needs to be trained specifically on successful and failed startups, investment memos, and due diligence reports.

2. Context Understanding

Investment AI must understand that a pitch deck isn't just a document to summarize. It's a set of claims that need validation against industry benchmarks and logical consistency.

3. Output Customization

Every investor has different risk tolerances, sector expertise, and deal criteria. The AI needs to adapt its analysis accordingly.

The New Standard for Angel Due Diligence

The angels who are getting the best deals in 2025 aren't the ones using AI to replace their judgment. They're using AI to enhance their pattern recognition. They're getting consistent, customized analysis that helps them ask better questions and spot red flags faster.

But here's the key: they're not just throwing pitch decks into whatever AI tool happens to be open. They're using purpose-built analysis that understands both investment fundamentals and their personal investment criteria.

Try It Yourself

If you want to see what proper AI-assisted due diligence looks like, you can test Respondra's pitch analysis feature yourself at respondra.com. Upload a pitch deck, set your own metric weightings, and see how specialized AI analysis differs from the generic responses you'd get elsewhere.

The difference isn't just better analysis. It's the difference between AI that makes you a better investor and AI that just makes you feel like you've done due diligence.

That's your 5% edge right there: using AI that's built for the job you're actually trying to do, not AI that's built for everything and optimized for nothing.

In my last article, I showed you how to fix canonical URLs when running Framer for marketing pages with Next.js for your app. But there's another integration detail that'll bite you if you're not careful: your sitemap.

The Sitemap Dilemma

When you're using Framer for marketing pages (/, /contact-us, /about) and Next.js for your app (/app/*), where does your sitemap live? And more importantly, how do you make sure search engines can find it?

Here's what most developers miss: your sitemap needs to be served from your root domain, but it also needs to include all your marketing pages that are actually hosted on Framer.

The Simple Solution

The fix is surprisingly straightforward. Create a static sitemap.xml file in your Next.js public folder:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">
<url>
<loc>https://respondra.com/</loc>
</url>
<url>
<loc>https://respondra.com/about</loc>
</url>
<url>
<loc>https://respondra.com/pricing</loc>
</url>
<url>
<loc>https://respondra.com/contact-us</loc>
</url>
<url>
<loc>https://respondra.com/terms</loc>
</url>
<url>
<loc>https://respondra.com/privacy</loc>
</url>
</urlset>

The Next.js Config Magic

The key is in your next.config.js. You need a specific rewrite rule that catches the sitemap request before your Framer fallback:

async rewrites() {
  return [
    {
      source: '/sitemap.xml',
      destination: '/sitemap.xml',
    },
    {
      source: '/blog/:path*',
      destination: 'https://blog.respondra.com/blog/:path*',
    },
    {
      source: '/:path((?!app)(?!blog)(?!sitemap.xml)(?!_next).*)',
      destination: 'https://www.respondra.com/:path*',
    },
  ];
}

Notice the order matters:

1. First, we explicitly handle /sitemap.xml to serve it from Next.js

2. Then we handle blog routes

3. Finally, we have the catch-all that excludes sitemap.xml and sends everything else to Framer

Why This Works

The magic is in that last rewrite rule: (?!sitemap.xml). This negative lookahead ensures that sitemap requests don't get forwarded to Framer. Instead, they're served directly from your Next.js public folder.

When Google crawls https://respondra.com/sitemap.xml, it gets served from your Next.js app, but all the URLs in the sitemap point to your marketing pages, which are seamlessly handled by your Framer rewrite rules.

Testing Your Sitemap

First, verify the technical setup:

1. Visit https://respondra.com/sitemap.xml in your browser

2. Check that you see your clean XML without any Framer interference

3. Run curl -I https://respondra.com/sitemap.xml to verify it returns proper headers

The Google Search Console Setup

Here's where most developers fumble the handoff. You've got your sitemap working, but now you need to tell Google about it properly.

Step 1: Property Setup Matters

Make sure you have the correct property set up in Google Search Console. You want the property for respondra.com (without www), not www.respondra.com. This should match your canonical URLs from the previous article.

If you currently have the www version as your main property:

1. Add the non-www version as a new property

2. Verify ownership using the HTML tag method or DNS verification

3. Set the non-www version as your preferred domain

Step 2: Submit Your Sitemap

In Google Search Console:

1. Navigate to Sitemaps in the left sidebar

2. Click Add a new sitemap

3. Enter sitemap.xml (just the filename, not the full URL)

4. Click Submit

Google will start processing it immediately. You should see it appear in the sitemaps list with a status of "Success" within a few minutes.

Step 3: Handle the Old Sitemap

If you previously had a sitemap submitted from your Framer setup (like www.respondra.com/sitemap.xml), you need to clean this up:

1. Find the old sitemap in your sitemaps list

2. Click on it and select Delete sitemap

3. This prevents confusion and ensures Google focuses on your new, correct sitemap

Step 4: Monitor the Results

Within 24-48 hours, check the sitemap performance:

1. Click on your new sitemap in the list

2. You should see "Discovered" and "Indexed" counts

3. All 6 URLs should show as discovered (this happens quickly)

4. Indexed count will grow over the following days as Google crawls

Common GSC Issues and Fixes

"Couldn't fetch" error: Your rewrite rules might not be working. Test the sitemap URL directly in an incognito browser.

"Has issues" status: Click into the details. Usually this means duplicate URLs or redirect chains. Make sure your canonical URL fixes from the previous article are working.

Low indexed count: Be patient. Google doesn't index everything immediately, especially if these are new URLs or your domain is relatively new.

Pro Tip: Use the URL Inspection Tool

After submitting your sitemap, test a few URLs:

1. Copy one of your marketing page URLs from the sitemap

2. Use the URL Inspection tool in GSC

3. Paste the URL and hit Enter

4. You should see "URL is on Google" or "URL can be indexed"

If you see issues here, it usually means your canonical URL setup needs work.

The Edge Case Most Miss

Here's what's clever about this setup: your sitemap lives in Next.js, but it references pages that are served by Framer. When Google crawls these URLs from your sitemap, they get seamlessly routed through your rewrite rules to Framer.

This means you get the best of both worlds - centralized sitemap control in your Next.js app, but all your marketing pages still benefit from Framer's speed and design capabilities.

Why This Matters

Without this setup, you'd either have:

• No sitemap (Google finds your pages slowly)

• Framer's default sitemap with wrong canonical URLs

• A sitemap that doesn't include your app routes

With this simple fix, search engines get a clear map of your entire site structure, served from the right domain, pointing to the right URLs.

The Real 5% Edge

Most developers running hybrid setups completely forget about the sitemap until they notice their pages aren't getting indexed properly. By handling this upfront, you ensure search engines can efficiently crawl and index your entire site.

This is exactly the kind of detail that compounds over time. Six months from now, when your marketing pages are ranking well and your app pages are properly indexed, you'll be glad you took the extra 10 minutes to get this right.

Next up: I'll show you how to handle analytics tracking across your hybrid setup. Because yes, there's another integration detail that most people miss.

In my last article, I showed you how to fix your SEO by moving from subdomains to subfolders using Next.js rewrites and Framer. But there's one critical piece I didn't cover and it's the kind of detail that can make or break your SEO setup.

The Problem Nobody Talks About

You've got your beautiful setup working: Framer handling your marketing site, Next.js handling your app, everything looking like one domain. Then you check your canonical URLs and... they're wrong.

Framer doesn't give you control over canonical URLs out of the box. So when Google crawls your site, it sees:

html

<link rel="canonical" href="https://www.respondra.com/pricing" />

But you want it to see:

html

<link rel="canonical" href="https://respondra.com/pricing" />

That www. might seem tiny, but to search engines, those are two different domains. You're diluting your SEO authority across multiple versions of the same URL.

When Support Doesn't Support

Here's where it gets frustrating. I reached out to Framer's support and sales team about this canonical URL issue. No response. Zero.

Look, I get it. They do offer a reverse proxy solution hosted on their side. But that's exactly the opposite of what I want as a developer. I want full control over reverse proxies on my end, not buried within the marketing website where I can't manage it properly.

This is exactly why developers hate reaching out for help. You spend time crafting a technical question, explaining your setup, and then... crickets. It's the kind of experience that makes you want to just build everything yourself.

But here's the thing. I still love Framer. It's genuinely great for what it does. My marketing team can move fast, the sites look beautiful, and the developer experience is solid. So instead of ditching it, I figured out the workaround.

Why This Matters More Than You Think

Search engines hate duplicate content. When you have both www.respondra.com/contact-us and respondra.com/contact-us pointing to the same content, you're essentially competing against yourself for rankings.

The canonical URL tells search engines: "This is the official version of this page." Get it wrong, and you're splitting your SEO juice between multiple URLs instead of concentrating it where it belongs.

The Two-Part Solution

Since Framer doesn't let us control canonical URLs directly, we need to fix this at two levels: server-side with Next.js middleware, and client-side with custom JavaScript.

Part 1: Next.js Middleware Fix

First, we catch and fix HTML responses on the server side. Here's the middleware that handles this:

import { NextRequest, NextResponse } from "next/server";

const allowedOrigins = ['https://respondra.com', 'https://respondra.dev'];

const corsOptions = {
  'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type, Authorization',
};

export async function middleware(request: NextRequest) {
  const response = NextResponse.next();
  
  // Add security headers
  response.headers.set('X-Frame-Options', 'DENY');
  response.headers.set('X-Content-Type-Options', 'nosniff');
  response.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin');
  response.headers.set('Permissions-Policy', 'camera=(), microphone=(), geolocation=()');
  
  // Existing CORS logic
  const origin = request.headers.get('origin') ?? '';
  const isAllowedOrigin = allowedOrigins.includes(origin);

  // Handle preflighted requests
  if (request.method === 'OPTIONS') {
    const preflightHeaders = {
      'Access-Control-Allow-Origin': isAllowedOrigin ? origin : 'No Origin Allowed',
      ...corsOptions,
    };
    return NextResponse.rewrite(new URL('/api/preflight', request.url), {
      headers: preflightHeaders,
      status: isAllowedOrigin ? 200 : 403,
      statusText: isAllowedOrigin ? 'OK' : 'Forbidden'
    });
  }

  // Handle simple requests
  if (isAllowedOrigin) {
    response.headers.set('Access-Control-Allow-Origin', origin);
  }

  // Handle HTML response rewriting for canonical URLs
  const contentType = response.headers.get('content-type');
  if (contentType?.includes('text/html')) {
    const html = await response.text();
    const modifiedHtml = html
      .replace(
        /<link\s+rel="canonical"\s+href="https:\/\/www\.respondra\.com([^"]*)"/g,
        '<link rel="canonical" href="https://respondra.com$1"'
      )
      .replace(
        /<meta\s+property="og:url"\s+content="https:\/\/www\.respondra\.com([^"]*)"/g,
        '<meta property="og:url" content="https://respondra.com$1"'
      );
    
    return new NextResponse(modifiedHtml, {
      status: response.status,
      statusText: response.statusText,
      headers: response.headers,
    });
  }

  return response;
}

The key part is the HTML rewriting section. We're intercepting HTML responses and using regex to replace any canonical URLs and Open Graph URLs that have www. with the clean version.

Part 2: Client-Side Framer Script

But middleware alone isn't enough. Framer might inject canonical URLs after the initial HTML loads, so we need client-side insurance. Add this script to your Framer site's Custom Code section:

<script>
  window.addEventListener('load', () => {
    const setCanonicalUrl = (url) => {
      // Update canonical URL
      const existingCanonical = document.querySelector('link[rel="canonical"]');
      if (existingCanonical) existingCanonical.remove();

      const canonicalLink = document.createElement('link');
      canonicalLink.rel = 'canonical';
      canonicalLink.href = url;
      document.head.appendChild(canonicalLink);

      // Update og:url
      const existingOgUrl = document.querySelector('meta[property="og:url"]');
      if (existingOgUrl) existingOgUrl.remove();

      const ogUrlMeta = document.createElement('meta');
      ogUrlMeta.setAttribute('property', 'og:url');
      ogUrlMeta.setAttribute('content', url);
      document.head.appendChild(ogUrlMeta);
    };

    // Remove 'www.' from current URL
    const currentUrl = window.location.href;
    let canonicalUrl = currentUrl.replace(/^https?:\/\/www\./, 'https://');

    // Fallback if not on respondra.com
    if (!canonicalUrl.includes('respondra.com')) {
      canonicalUrl = currentUrl;
    }

    setCanonicalUrl(canonicalUrl);
  });
</script>

This script waits for the page to fully load, then removes any existing canonical and og:url tags and replaces them with the correct versions without www..

Why Both Solutions?

You might wonder why we need both middleware and client-side fixes. Here's the deal:

Middleware: Catches most cases and ensures search engine crawlers see the right canonical URLs immediately Client-side script: Insurance policy for any dynamic content or edge cases where Framer injects tags after page load

Together, they create a bulletproof system that ensures your canonical URLs are always correct.

Testing Your Setup

Want to verify this is working? Here's how:

1. Visit your marketing pages

2. View page source (Ctrl+U or Cmd+U)

3. Search for "canonical"

4. Confirm you see href="https://yourdomain.com/path" without www

You should also check that your Open Graph URLs are consistent for social media sharing.

The Real 5% Edge

This canonical URL fix might seem like overkill, but it's exactly the kind of detail that separates good implementations from great ones. Your marketing team gets their independence, your SEO stays strong, and you don't lose ranking authority to duplicate URLs.

Most developers who do the subdomain-to-subfolder migration miss this step entirely. Then six months later, they wonder why their SEO isn't improving as much as expected.

That's your 5% edge right there - handling the details that matter but are easy to overlook.

What's Next?

In the next article, I'll show you how to handle the sitemap challenge when you're running this hybrid setup. Because yes, there's another integration detail that most people miss.

A marketer once asked me to move our site from subdomains to subfolders for SEO. I couldn't figure it out at the time and felt terrible. Here's how I solved it... and why these final integration challenges are what I call the 5% edge.

The "Easy" Solution Trap

Let's talk about how engineers think about "easy" solutions. When you're building a SaaS, the obvious move seems to be: build everything as one app. Marketing pages, authentication, dashboard - all in one Next.js application. Simple, right?

Wrong.

Here's what happens: Your marketing team wants to update the homepage. They come to you. You become the gatekeeper for every single marketing change. Even worse? You start giving non-marketing, data-driven opinions about their copy changes. Trust me, marketers hate this. You've just created a bottleneck that will slow down your entire go-to-market strategy.

The Problem That Stuck With Me

This happened to me. A marketer asked me to move from subdomains to subfolders because subdomains hurt SEO rankings. I eventually figured out how to solve it, but by then we had way too many dependencies built up. The fix was extremely messy - like trying to renovate a house while people are still living in it.

I felt like I'd let the team down by not thinking about this earlier. After I left that company, this problem stuck with me. I was determined never to make this architectural mistake early on again. I spent time figuring out the clean way to do this from the start, because I never wanted a future marketer to have to deal with a messy retrofit.

Finding the 5% Edge

Here's the thing about these integration problems - they're always that last 5% that trips us up. But here's the actual easy solution: Give your marketing team independence with a no-code tool like Framer, then use Next.js rewrites to make it all look like one domain.

Let me show you exactly how I set this up for Respondra:

• Marketing site: Built in Framer at respondra.com (marketers can edit freely)

• App: Built in Next.js at respondra.com/app

• Clean subfolder structure for SEO

The magic happens in your next.config.js file with rewrite logic. This file is the glue holding everything together - it's the true 5% push that makes the whole system work:

/** @type {import('next').NextConfig} */

const nextConfig = {
  reactStrictMode: false,
  images: {
    remotePatterns: [
      {
        protocol: 'https',
        hostname: 'lh3.googleusercontent.com',
        port: '',
        pathname: '**',
      },
      // ... other image patterns
    ],
  },
  async redirects() {
    return [
      {
        source: '/app/:path*',
        has: [
          {
            type: 'host',
            value: 'www.respondra.com',
          },
        ],
        destination: 'https://respondra.com/app/:path*',
        permanent: true,
      },
    ];
  },
  async rewrites() {
    return [
      {
        source: '/sitemap.xml',
        destination: '/sitemap.xml',
      },
      {
        source: '/blog/:path*',
        destination: 'https://blog.respondra.com/blog/:path*',
      },
      {
        source: '/:path((?!app)(?!blog)(?!sitemap.xml)(?!_next).*)',
        destination: 'https://www.respondra.com/:path*',
      },
    ];
  }
};

module.exports = nextConfig;

Here's what's happening:

1. The rewrite rule /:path((?!app)(?!blog)(?!sitemap.xml)(?!_next).*) catches any path that's NOT /app, /blog, /sitemap.xml, or /_next

2. It forwards those requests to https://www.respondra.com/:path* (your Framer site)

3. Your Next.js app handles /app routes directly

4. Cloudflare points your domain to the Next.js app running on GCP

5. The Next.js app seamlessly proxies marketing requests to Framer

This configuration file is doing all the heavy lifting, and it's the integration layer that makes everything appear as one cohesive site while keeping your marketing and app completely separate.

The Three Wins

This approach gives you three major advantages:

1. Your marketing team moves fast without you

2. Your SEO stays strong with subfolder structure

3. You focus on building product instead of updating hero sections

At Respondra, my future marketers can update the homepage without ever touching code. I can focus on just building the product.

That's the 5% Edge

The 5% edge isn't just about writing code that works, it's about writing code that works for your entire team. These integration challenges might seem small, but they're often what separates developers who ship successful products from those who get stuck in endless cycles of "almost done."

Sometimes the best solutions come from problems that stick with us. What integration challenge has been nagging at you? The one that seems too small to matter but keeps causing friction? That might be exactly where you need to find your 5% edge.