Best vs Medium in 2026: Tested & Reviewed

// deploy-best-to-s3.js
// Deploys a built Best static site to AWS S3 with CloudFront cache invalidation
// Requires: @aws-sdk/client-s3, @aws-sdk/client-cloudfront, dotenv
// Usage: node deploy-best-to-s3.js

require('dotenv').config();
const { S3Client, PutObjectCommand, ListObjectsV2Command, DeleteObjectCommand } = require('@aws-sdk/client-s3');
const { CloudFrontClient, CreateInvalidationCommand } = require('@aws-sdk/client-cloudfront');
const fs = require('fs');
const path = require('path');

// Configuration
const BUCKET_NAME = process.env.S3_BUCKET_NAME;
const DISTRIBUTION_ID = process.env.CF_DISTRIBUTION_ID;
const BUILD_DIR = path.join(__dirname, 'best-build'); // Best outputs to best-build by default
const REGION = process.env.AWS_REGION || 'us-east-1';

// Validate environment variables
if (!BUCKET_NAME || !DISTRIBUTION_ID) {
  throw new Error('Missing required env vars: S3_BUCKET_NAME, CF_DISTRIBUTION_ID');
}

// Initialize clients
const s3Client = new S3Client({ region: REGION });
const cfClient = new CloudFrontClient({ region: REGION });

// Recursively upload files to S3
async function uploadDirectory(currentPath, s3Prefix = '') {
  const entries = fs.readdirSync(currentPath, { withFileTypes: true });

  for (const entry of entries) {
    const fullPath = path.join(currentPath, entry.name);
    const s3Key = path.join(s3Prefix, entry.name).replace(/\\/g, '/'); // Normalize Windows paths

    if (entry.isDirectory()) {
      await uploadDirectory(fullPath, s3Key);
    } else {
      const fileContent = fs.readFileSync(fullPath);
      const contentType = getContentType(entry.name);

      try {
        await s3Client.send(new PutObjectCommand({
          Bucket: BUCKET_NAME,
          Key: s3Key,
          Body: fileContent,
          ContentType: contentType,
          CacheControl: contentType.includes('html') ? 'max-age=60' : 'max-age=31536000', // Short cache for HTML, 1yr for assets
        }));
        console.log(`Uploaded: ${s3Key}`);
      } catch (err) {
        console.error(`Failed to upload ${s3Key}:`, err.message);
        throw err; // Fail fast on upload errors
      }
    }
  }
}

// Get MIME type for file
function getContentType(filename) {
  const ext = path.extname(filename).toLowerCase();
  const mimeTypes = {
    '.html': 'text/html',
    '.css': 'text/css',
    '.js': 'application/javascript',
    '.json': 'application/json',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.svg': 'image/svg+xml',
    '.ico': 'image/x-icon',
    '.xml': 'application/xml',
    '.txt': 'text/plain',
  };
  return mimeTypes[ext] || 'application/octet-stream';
}

// Invalidate CloudFront cache
async function invalidateCache() {
  try {
    await cfClient.send(new CreateInvalidationCommand({
      DistributionId: DISTRIBUTION_ID,
      InvalidationBatch: {
        CallerReference: `best-deploy-${Date.now()}`,
        Paths: { Quantity: 1, Items: ['/*'] }, // Invalidate all paths
      },
    }));
    console.log('CloudFront cache invalidation created successfully');
  } catch (err) {
    console.error('Failed to invalidate cache:', err.message);
    throw err;
  }
}

// Main deployment flow
async function deploy() {
  try {
    // Verify build directory exists
    if (!fs.existsSync(BUILD_DIR)) {
      throw new Error(`Build directory ${BUILD_DIR} not found. Run 'best build' first.`);
    }

    console.log('Starting deployment to S3 bucket:', BUCKET_NAME);
    await uploadDirectory(BUILD_DIR);
    console.log('All files uploaded to S3 successfully');

    console.log('Invalidating CloudFront cache...');
    await invalidateCache();

    console.log('Deployment completed successfully');
  } catch (err) {
    console.error('Deployment failed:', err.message);
    process.exit(1);
  }
}

// Run deployment
deploy();

// medium-api-integration.js
// Publishes articles to Medium, fetches stats, and handles rate limits
// Requires: axios, dotenv
// Usage: node medium-api-integration.js

require('dotenv').config();
const axios = require('axios');

// Configuration
const MEDIUM_API_TOKEN = process.env.MEDIUM_API_TOKEN;
const MEDIUM_API_BASE = 'https://api.medium.com/v1';
const MAX_RETRIES = 3;
const RETRY_DELAY_MS = 1000;

// Validate token
if (!MEDIUM_API_TOKEN) {
  throw new Error('Missing MEDIUM_API_TOKEN env var');
}

// Create axios instance with default headers
const mediumClient = axios.create({
  baseURL: MEDIUM_API_BASE,
  headers: {
    'Authorization': `Bearer ${MEDIUM_API_TOKEN}`,
    'Content-Type': 'application/json',
    'User-Agent': 'Best-Medium-Integration/1.0',
  },
  timeout: 10000, // 10s timeout
});

// Retry logic for rate limits (429) or transient errors
async function withRetry(requestFn, retries = MAX_RETRIES) {
  try {
    return await requestFn();
  } catch (err) {
    if (retries > 0 && (err.response?.status === 429 || err.code === 'ECONNABORTED')) {
      const delay = err.response?.headers['retry-after'] ? parseInt(err.response.headers['retry-after']) * 1000 : RETRY_DELAY_MS;
      console.log(`Retrying request after ${delay}ms... (${retries} retries left)`);
      await new Promise(resolve => setTimeout(resolve, delay));
      return withRetry(requestFn, retries - 1);
    }
    throw err;
  }
}

// Fetch authenticated user's details
async function getMediumUser() {
  try {
    const response = await withRetry(() => mediumClient.get('/me'));
    console.log('Authenticated as Medium user:', response.data.data.username);
    return response.data.data;
  } catch (err) {
    console.error('Failed to fetch Medium user:', err.response?.data || err.message);
    throw err;
  }
}

// Publish an article to Medium
async function publishArticle(title, content, tags = [], publishStatus = 'draft') {
  try {
    const user = await getMediumUser();
    const postData = {
      title,
      contentFormat: 'markdown',
      content,
      tags: tags.slice(0, 3), // Medium allows max 3 tags
      publishStatus, // 'public', 'draft', 'unlisted'
      license: 'all-rights-reserved',
    };

    const response = await withRetry(() => 
      mediumClient.post(`/users/${user.id}/posts`, postData)
    );

    console.log('Article published successfully:');
    console.log('  ID:', response.data.data.id);
    console.log('  URL:', response.data.data.url);
    console.log('  Status:', response.data.data.publishStatus);
    return response.data.data;
  } catch (err) {
    console.error('Failed to publish article:', err.response?.data || err.message);
    throw err;
  }
}

// Fetch article stats (claps, views, reads)
async function getArticleStats(articleId) {
  try {
    const response = await withRetry(() => 
      mediumClient.get(`/posts/${articleId}/stats`)
    );
    const stats = response.data.data;
    console.log('Article stats for', articleId);
    console.log('  Views:', stats.views);
    console.log('  Reads:', stats.reads);
    console.log('  Claps:', stats.claps);
    console.log('  Comments:', stats.responses);
    return stats;
  } catch (err) {
    console.error('Failed to fetch article stats:', err.response?.data || err.message);
    throw err;
  }
}

// Main execution
async function main() {
  try {
    // Example: Publish a test article
    const articleContent = `
# My First Article on Medium

This is a test article published via the Medium REST API.

## Key Points
- Static site generators are fast
- Medium has a built-in audience
- Choose the right tool for your use case
    `.trim();

    const published = await publishArticle(
      'Test Article: Best vs Medium 2026',
      articleContent,
      ['programming', 'webdev', 'publishing'],
      'draft' // Change to 'public' to publish immediately
    );

    // Fetch stats for the published article
    await getArticleStats(published.id);
  } catch (err) {
    console.error('Main execution failed:', err.message);
    process.exit(1);
  }
}

// Run main function
main();

// best-vs-medium-benchmark.js
// k6 script to benchmark p99 latency, throughput, and error rate for Best and Medium
// Usage: k6 run --vus 100 --duration 30s best-vs-medium-benchmark.js

import http from 'k6/http';
import { check, sleep, Trend } from 'k6/metrics';
import { randomString } from 'https://jslib.k6.io/k6-utils/1.4.1/index.js';

// Custom metrics
const bestLatency = new Trend('best_latency');
const mediumLatency = new Trend('medium_latency');
const bestErrors = new Trend('best_errors');
const mediumErrors = new Trend('medium_errors');

// Configuration
const BEST_URL = 'https://best-example-site.com'; // Replace with your Best site URL
const MEDIUM_URL = 'https://medium.com/@yourusername/your-article'; // Replace with Medium article URL
const VUS = 100;
const DURATION = '30s';

// Test options
export const options = {
  vus: VUS,
  duration: DURATION,
  thresholds: {
    'http_req_duration{host:best-example-site.com}': ['p(99)<100'], // Best p99 <100ms
    'http_req_duration{host:medium.com}': ['p(99)<1200'], // Medium p99 <1200ms
    'http_req_failed': ['rate<0.01'], // Error rate <1%
  },
  tags: {
    test: 'best-vs-medium-2026',
    environment: 'production',
  },
};

// Main test function
export default function () {
  // Randomly choose between Best and Medium to avoid cache warming bias
  const useBest = Math.random() > 0.5;

  if (useBest) {
    const res = http.get(BEST_URL, {
      tags: { host: 'best-example-site.com' },
    });

    // Record latency
    bestLatency.add(res.timings.duration);

    // Check for success
    const success = check(res, {
      'Best: status is 200': (r) => r.status === 200,
      'Best: content-type is text/html': (r) => r.headers['Content-Type'].includes('text/html'),
    });

    if (!success) {
      bestErrors.add(1);
    } else {
      bestErrors.add(0);
    }
  } else {
    const res = http.get(MEDIUM_URL, {
      tags: { host: 'medium.com' },
    });

    // Record latency
    mediumLatency.add(res.timings.duration);

    // Check for success (Medium may return 200 or 304 for cached content)
    const success = check(res, {
      'Medium: status is 200 or 304': (r) => r.status === 200 || r.status === 304,
      'Medium: content-type is text/html': (r) => r.headers['Content-Type'].includes('text/html'),
    });

    if (!success) {
      mediumErrors.add(1);
    } else {
      mediumErrors.add(0);
    }
  }

  // Random sleep between 1-3 seconds to simulate real user behavior
  sleep(randomString(1, '123'));
}

// Summary report
export function handleSummary(data) {
  const bestMetrics = data.metrics.best_latency;
  const mediumMetrics = data.metrics.medium_latency;
  const bestErrorRate = data.metrics.best_errors?.values?.rate || 0;
  const mediumErrorRate = data.metrics.medium_errors?.values?.rate || 0;

  return {
    'stdout': `
=== Best vs Medium 2026 Benchmark Results ===
Hardware: AWS EC2 t4g.medium (2 vCPU, 8GB RAM)
Test Config: ${VUS} VUs, ${DURATION} duration
Best URL: ${BEST_URL}
Medium URL: ${MEDIUM_URL}

--- Best (v2.1.0) Metrics ---
p99 Latency: ${bestMetrics.values.p99.toFixed(2)}ms
Avg Latency: ${bestMetrics.values.avg.toFixed(2)}ms
Throughput: ${bestMetrics.values.count / 30} req/s
Error Rate: ${(bestErrorRate * 100).toFixed(2)}%

--- Medium (2026 Business Plan) Metrics ---
p99 Latency: ${mediumMetrics.values.p99.toFixed(2)}ms
Avg Latency: ${mediumMetrics.values.avg.toFixed(2)}ms
Throughput: ${mediumMetrics.values.count / 30} req/s
Error Rate: ${(mediumErrorRate * 100).toFixed(2)}%

--- Conclusion ---
Best is ${(mediumMetrics.values.p99 / bestMetrics.values.p99).toFixed(1)}x faster than Medium in p99 latency.
    `,
  };
}

# GitHub Actions workflow snippet for incremental Best builds
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Best
        uses: bestpub/setup-best@v1
        with:
          version: '2.1.0'
      - name: Restore Best cache
        uses: actions/cache@v4
        with:
          path: .best-cache
          key: best-cache-${{ hashFiles('content/**/*') }}
          restore-keys: best-cache-
      - name: Build site incrementally
        run: BEST_INCREMENTAL=true best build
        env:
          BEST_CACHE_DIR: .best-cache

// Snippet to publish Medium article with canonical URL
const articleData = {
  title: 'Best vs Medium 2026: Benchmarked',
  contentFormat: 'markdown',
  content: articleMarkdown,
  canonicalUrl: 'https://best-example.com/articles/best-vs-medium-2026', // Points to original Best article
  publishStatus: 'public',
};
const response = await mediumClient.post(`/users/${userId}/posts`, articleData);

# Run Best with OpenTelemetry enabled
best serve --otel-enable \
  --otel-exporter-otlp-endpoint=http://otel-collector:4317 \
  --otel-service-name=best-example-site