<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[JavaScript in Plain English - Medium]]></title>
        <description><![CDATA[New JavaScript and Web Development content every day. Follow to join our 3.5M+ monthly readers. - Medium]]></description>
        <link>https://javascript.plainenglish.io?source=rss----4b3a1ed4f11c---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>JavaScript in Plain English - Medium</title>
            <link>https://javascript.plainenglish.io?source=rss----4b3a1ed4f11c---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:35:40 GMT</lastBuildDate>
        <atom:link href="https://javascript.plainenglish.io/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[How to Start a 1-Person AI Business Using Claude in 2027]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/how-to-start-a-1-person-ai-business-using-claude-in-2027-9d1a4063ee24?source=rss----4b3a1ed4f11c---4"><img src="https://cdn-images-1.medium.com/max/1672/1*yO0Rw1L6suZwZSPWP5f-vw.png" width="1672"></a></p><p class="medium-feed-snippet">My playbook as a developer: pick a boring problem, make Claude your business memory, sell by hand first, and automate last.</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/how-to-start-a-1-person-ai-business-using-claude-in-2027-9d1a4063ee24?source=rss----4b3a1ed4f11c---4">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/how-to-start-a-1-person-ai-business-using-claude-in-2027-9d1a4063ee24?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/9d1a4063ee24</guid>
            <category><![CDATA[entrepreneurship]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[business]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Shubh Jain]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 18:58:27 GMT</pubDate>
            <atom:updated>2026-11-16T18:58:26.181Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[I Built a JavaScript Tool That Reveals Which SaaS Features Customers Actually Use]]></title>
            <link>https://javascript.plainenglish.io/i-built-a-javascript-tool-that-reveals-which-saas-features-customers-actually-use-0cf160a8dcad?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/0cf160a8dcad</guid>
            <dc:creator><![CDATA[Suleman Safdar]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 18:52:15 GMT</pubDate>
            <atom:updated>2026-11-16T18:52:13.921Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>I used to think a feature was successful whenever users clicked it. Then I started looking at what happened after the click. Some features attracted attention but never became part of anyone’s routine, while others quietly became essential. That realization led me to build a feature adoption intelligence dashboard that turns raw product events into decisions a SaaS team can actually use.</em></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N_rIHhssH8SemAepMkaLbg.jpeg" /></figure><h3>1. The Feature Adoption Problem Nobody Notices Until It Gets Expensive</h3><p>Imagine launching a new feature after three weeks of development. The announcement gets attention, users open the feature, and the team celebrates.</p><p>A month later, nobody knows whether it actually improved the product.</p><p>The analytics dashboard shows page views, button clicks, and total events. But those numbers don’t answer the important questions:</p><ul><li>How many unique users tried the feature?</li><li>How many returned to use it again?</li><li>How long did it take users to discover it?</li><li>Which customer segments adopted it?</li><li>Where did people abandon the experience?</li></ul><p>A click is not adoption. A page view is not value. Even repeated usage can be misleading if the feature is only being used because users have no alternative.</p><p>I wanted a tool that could distinguish curiosity from genuine product adoption.</p><p>So I built a small JavaScript application that collects product events, groups them into meaningful user journeys, calculates adoption metrics, and displays the results in a dashboard.</p><p>The goal wasn’t to create another analytics platform. It was to answer one practical question:</p><p><strong>Which features are becoming part of customers’ workflows, and which ones are being ignored?</strong></p><h3>2. I Started by Defining What Adoption Actually Means</h3><p>Before writing code, I needed a consistent definition of feature adoption.</p><p>For this project, a feature is considered adopted when a user performs a meaningful action associated with it. We also track whether that user returns within a defined period.</p><p>For example:</p><ul><li>feature_viewed: The user opened the feature.</li><li>feature_action_completed: The user successfully used it.</li><li>feature_saved: The user saved an outcome.</li><li>feature_reused: The user returned to use it again.</li></ul><p>This distinction matters because opening a feature and successfully completing an action are two different behaviors.</p><p>I started with a simple event structure.</p><pre>const event = {<br>  id: crypto.randomUUID(),<br>  userId: &quot;user_102&quot;,<br>  workspaceId: &quot;workspace_21&quot;,<br>  feature: &quot;ai_report_builder&quot;,<br>  eventName: &quot;feature_action_completed&quot;,<br>  timestamp: new Date().toISOString(),<br>  properties: {<br>    action: &quot;report_generated&quot;,<br>    plan: &quot;pro&quot;<br>  }<br>};</pre><p>Every event contains enough information to identify the user, workspace, feature, action, and time.</p><p>The properties object stores optional context. For example, a report builder might record the report type, while an export feature might record the export format.</p><p>One important decision: I wouldn’t store sensitive customer content inside analytics events. Product analytics should describe behavior, not become an accidental copy of private customer data.</p><h3>3. I Built an Event Collector Before Building the Dashboard</h3><p>The first component was a lightweight event collector.</p><p>I wanted developers to track feature usage without writing complicated analytics logic throughout their applications.</p><p>Here’s a reusable JavaScript implementation.</p><pre>class ProductAnalytics {<br>  constructor(apiUrl) {<br>    this.apiUrl = apiUrl;<br>    this.queue = [];<br>  }<br>  track({<br>    userId,<br>    workspaceId,<br>    feature,<br>    eventName,<br>    properties = {}<br>  }) {<br>    if (!userId || !feature || !eventName) {<br>      throw new Error(<br>        &quot;userId, feature and eventName are required&quot;<br>      );<br>    }<br>    const event = {<br>      id: crypto.randomUUID(),<br>      userId,<br>      workspaceId,<br>      feature,<br>      eventName,<br>      timestamp: new Date().toISOString(),<br>      properties<br>    };<br>    this.queue.push(event);<br>    return event;<br>  }<br>  async flush() {<br>    if (this.queue.length === 0) {<br>      return;<br>    }<br>    const batch = [...this.queue];<br>    const response = await fetch(<br>      `${this.apiUrl}/events`,<br>      {<br>        method: &quot;POST&quot;,<br>        headers: {<br>          &quot;Content-Type&quot;: &quot;application/json&quot;<br>        },<br>        body: JSON.stringify({<br>          events: batch<br>        })<br>      }<br>    );<br>    if (!response.ok) {<br>      throw new Error(<br>        `Event upload failed: ${response.status}`<br>      );<br>    }<br>    this.queue = this.queue.filter(<br>      event =&gt; !batch.some(<br>        sent =&gt; sent.id === event.id<br>      )<br>    );<br>  }<br>}<br>const analytics = new ProductAnalytics(<br>  &quot;https://api.example.com&quot;<br>);<br>analytics.track({<br>  userId: &quot;user_102&quot;,<br>  workspaceId: &quot;workspace_21&quot;,<br>  feature: &quot;ai_report_builder&quot;,<br>  eventName: &quot;feature_action_completed&quot;,<br>  properties: {<br>    reportType: &quot;monthly&quot;<br>  }<br>});</pre><p>The track() method creates an event and places it in a queue. It doesn&#39;t make an HTTP request every time a button is clicked.</p><p>That’s intentional.</p><p>Imagine a user performing 20 actions in a few seconds. Sending 20 separate network requests would create unnecessary overhead.</p><p>Instead, the application collects events and uploads them in batches.</p><p>For production, I’d add automatic flush intervals, maximum queue sizes, retry policies with exponential backoff, and a sendBeacon() strategy for suitable page-exit scenarios. The queue should also have a carefully designed persistence strategy if losing events is unacceptable.</p><h3>4. I Created a Backend That Stores Events Reliably</h3><p>A browser can collect events, but it shouldn’t be responsible for calculating the company’s official adoption metrics.</p><p>The backend needs to validate incoming events, normalize their structure, and store them.</p><p>For a lightweight prototype, Node.js, Express, and SQLite are enough.</p><p>Install the dependencies:</p><pre>npm init -y<br>npm install express better-sqlite3 cors<br>npm install --save-dev nodemon</pre><p>Create server.js:</p><pre>const express = require(&quot;express&quot;);<br>const Database = require(&quot;better-sqlite3&quot;);<br>const cors = require(&quot;cors&quot;);<br>const app = express();<br>const db = new Database(&quot;analytics.db&quot;);<br>app.use(cors());<br>app.use(express.json({ limit: &quot;1mb&quot; }));<br>db.exec(`<br>  CREATE TABLE IF NOT EXISTS events (<br>    id TEXT PRIMARY KEY,<br>    user_id TEXT NOT NULL,<br>    workspace_id TEXT,<br>    feature TEXT NOT NULL,<br>    event_name TEXT NOT NULL,<br>    timestamp TEXT NOT NULL,<br>    properties TEXT<br>  )<br>`);<br>const insertEvent = db.prepare(`<br>  INSERT OR IGNORE INTO events (<br>    id,<br>    user_id,<br>    workspace_id,<br>    feature,<br>    event_name,<br>    timestamp,<br>    properties<br>  )<br>  VALUES (?, ?, ?, ?, ?, ?, ?)<br>`);<br>app.post(&quot;/events&quot;, (req, res) =&gt; {<br>  const events = req.body.events;<br>  if (!Array.isArray(events) || events.length &gt; 500) {<br>    return res.status(400).json({<br>      error: &quot;Invalid event batch&quot;<br>    });<br>  }<br>  const insertMany = db.transaction(items =&gt; {<br>    for (const event of items) {<br>      if (<br>        !event.id ||<br>        !event.userId ||<br>        !event.feature ||<br>        !event.eventName ||<br>        !event.timestamp ||<br>        Number.isNaN(Date.parse(event.timestamp))<br>      ) {<br>        throw new Error(&quot;Invalid event structure&quot;);<br>      }<br>      insertEvent.run(<br>        event.id,<br>        event.userId,<br>        event.workspaceId || null,<br>        event.feature,<br>        event.eventName,<br>        event.timestamp,<br>        JSON.stringify(event.properties || {})<br>      );<br>    }<br>  });<br>  try {<br>    insertMany(events);<br>    res.status(202).json({<br>      accepted: events.length<br>    });<br>  } catch (error) {<br>    res.status(400).json({<br>      error: error.message<br>    });<br>  }<br>});<br>app.listen(3000, () =&gt; {<br>  console.log(<br>    &quot;Analytics server running on port 3000&quot;<br>  );<br>});</pre><p>The database uses an event ID as its primary key. This makes repeated submissions of the same event idempotent: a retry won’t create another copy.</p><p>That small detail becomes important when network connections fail. If the client doesn’t receive a response, it may retry an upload even though the server already received it.</p><p>For a real commercial product, this prototype also needs authentication, workspace-level authorization, rate limiting, event schema versioning, stricter validation, and database retention policies. CORS alone is not security.</p><h3>5. I Turned Raw Events Into Meaningful Adoption Metrics</h3><p>Now came the interesting part.</p><p>A database full of events is not automatically useful. I needed to convert those events into metrics that product managers could understand.</p><p>I started with four:</p><p><strong>Reach:</strong> How many unique users performed a meaningful action?</p><p><strong>Activation:</strong> What percentage of users who tried a feature completed its core action?</p><p><strong>Repeat usage:</strong> What percentage of users returned and used it again?</p><p><strong>Adoption rate:</strong> What percentage of eligible users adopted the feature?</p><p>The distinction between eligible users and all registered users is important. If a feature is only available on the Pro plan, counting free-plan users in the adoption denominator makes the feature appear less successful than it really is.</p><p>Here’s a simple calculation engine.</p><pre>function calculateAdoption(events, eligibleUsers) {<br>  const coreActions = new Set([<br>    &quot;feature_action_completed&quot;,<br>    &quot;feature_saved&quot;,<br>    &quot;feature_reused&quot;<br>  ]);<br>  const adopters = new Set();<br>  const viewers = new Set();<br>  const usageByUser = new Map();<br>  for (const event of events) {<br>    if (event.eventName === &quot;feature_viewed&quot;) {<br>      viewers.add(event.userId);<br>    }<br>    if (coreActions.has(event.eventName)) {<br>      adopters.add(event.userId);<br>      if (!usageByUser.has(event.userId)) {<br>        usageByUser.set(event.userId, 0);<br>      }<br>      usageByUser.set(<br>        event.userId,<br>        usageByUser.get(event.userId) + 1<br>      );<br>    }<br>  }<br>  const repeatUsers = [...usageByUser.values()]<br>    .filter(count =&gt; count &gt;= 2).length;<br>  const totalEligible = eligibleUsers.length;<br>  return {<br>    eligibleUsers: totalEligible,<br>    viewers: viewers.size,<br>    adopters: adopters.size,<br>    adoptionRate: totalEligible<br>      ? adopters.size / totalEligible<br>      : 0,<br>    activationRate: viewers.size<br>      ? adopters.size / viewers.size<br>      : 0,<br>    repeatUsageRate: adopters.size<br>      ? repeatUsers / adopters.size<br>      : 0<br>  };<br>}</pre><p>This gives us a starting point, but there’s an important limitation: this function calculates repeat usage across the entire supplied event set, not within a specific time window.</p><p>A production implementation should calculate repeat usage over a defined period, such as seven or thirty days, and distinguish separate sessions where appropriate.</p><p>Otherwise, a user who clicked a feature twice within five seconds could appear just as engaged as someone who returned every week.</p><p>That is exactly the kind of misleading metric I wanted this tool to prevent.</p><h3>6. I Added Feature-Level Reports Instead of One Giant Number</h3><p>Once the calculations worked, I needed to compare features.</p><p>A single adoption percentage isn’t enough. A product might have one highly successful feature hiding five features that nobody uses.</p><p>I created a reporting function that groups events by feature.</p><pre>function generateFeatureReport(<br>  events,<br>  eligibleUsersByFeature<br>) {<br>  const features = [<br>    ...new Set(events.map(event =&gt; event.feature))<br>  ];<br>  return features.map(feature =&gt; {<br>    const featureEvents = events.filter(<br>      event =&gt; event.feature === feature<br>    );<br>    const eligibleUsers =<br>      eligibleUsersByFeature[feature] || [];<br>    const metrics = calculateAdoption(<br>      featureEvents,<br>      eligibleUsers<br>    );<br>    return {<br>      feature,<br>      ...metrics,<br>      totalEvents: featureEvents.length<br>    };<br>  });<br>}</pre><p>Example output:</p><pre>[<br>  {<br>    feature: &quot;ai_report_builder&quot;,<br>    eligibleUsers: 500,<br>    viewers: 240,<br>    adopters: 180,<br>    adoptionRate: 0.36,<br>    activationRate: 0.75,<br>    repeatUsageRate: 0.60,<br>    totalEvents: 410<br>  },<br>  {<br>    feature: &quot;bulk_export&quot;,<br>    eligibleUsers: 500,<br>    viewers: 300,<br>    adopters: 75,<br>    adoptionRate: 0.15,<br>    activationRate: 0.25,<br>    repeatUsageRate: 0.20,<br>    totalEvents: 350<br>  }<br>]</pre><p>The report tells an interesting story.</p><p>The bulk export feature attracts more viewers, but far fewer people complete its core action. That suggests a discovery-to-activation problem.</p><p>The AI report builder attracts fewer viewers but converts a much larger proportion into actual users.</p><p>That doesn’t automatically prove the AI feature is better. We still need to consider customer segments, feature availability, usage frequency, and the value customers receive.</p><p>But now we have a useful direction for investigation.</p><h3>7. I Built a Dashboard That Makes the Numbers Understandable</h3><p>I didn’t want product managers to read JSON or run database queries just to answer basic questions.</p><p>The dashboard needed to display the important metrics in a format that could be understood in seconds.</p><p>For a browser-based prototype, Chart.js is a straightforward choice.</p><p>Install it:</p><pre>npm install chart.js</pre><p>Here’s a basic dashboard component using React.</p><pre>import {<br>  Bar<br>} from &quot;react-chartjs-2&quot;;<br>import {<br>  Chart as ChartJS,<br>  CategoryScale,<br>  LinearScale,<br>  BarElement,<br>  Tooltip,<br>  Legend<br>} from &quot;chart.js&quot;;<br>ChartJS.register(<br>  CategoryScale,<br>  LinearScale,<br>  BarElement,<br>  Tooltip,<br>  Legend<br>);<br>export default function AdoptionDashboard({<br>  reports<br>}) {<br>  const chartData = {<br>    labels: reports.map(<br>      item =&gt; item.feature<br>    ),<br>    datasets: [<br>      {<br>        label: &quot;Adoption Rate (%)&quot;,<br>        data: reports.map(<br>          item =&gt; item.adoptionRate * 100<br>        )<br>      }<br>    ]<br>  };<br>  return (<br>    &lt;main&gt;<br>      &lt;h1&gt;Feature Adoption Intelligence&lt;/h1&gt;<br>      &lt;p&gt;<br>        Compare how customers discover,<br>        activate and reuse product features.<br>      &lt;/p&gt;<br>      &lt;Bar<br>        data={chartData}<br>        options={{<br>          responsive: true,<br>          plugins: {<br>            legend: {<br>              display: true<br>            }<br>          },<br>          scales: {<br>            y: {<br>              beginAtZero: true,<br>              max: 100<br>            }<br>          }<br>        }}<br>      /&gt;<br>      &lt;section&gt;<br>        {reports.map(report =&gt; (<br>          &lt;article key={report.feature}&gt;<br>            &lt;h3&gt;{report.feature}&lt;/h3&gt;<br>            &lt;p&gt;<br>              Adoption:{&quot; &quot;}<br>              {(report.adoptionRate * 100).toFixed(1)}%<br>            &lt;/p&gt;<br>            &lt;p&gt;<br>              Activation:{&quot; &quot;}<br>              {(report.activationRate * 100).toFixed(1)}%<br>            &lt;/p&gt;<br>            &lt;p&gt;<br>              Repeat usage:{&quot; &quot;}<br>              {(report.repeatUsageRate * 100).toFixed(1)}%<br>            &lt;/p&gt;<br>          &lt;/article&gt;<br>        ))}<br>      &lt;/section&gt;<br>    &lt;/main&gt;<br>  );<br>}</pre><p>The chart gives the team a quick comparison, while the individual feature cards provide context.</p><p>I would eventually add date filters, plan filters, workspace segmentation, and a drill-down view showing the journey from feature discovery to successful completion.</p><p>The important thing is that the dashboard should encourage investigation, not simply display impressive-looking numbers.</p><h3>8. The Most Valuable Discovery Was Finding Where Users Get Stuck</h3><p>Once adoption metrics were available, I wanted to understand why certain features weren’t being adopted.</p><p>Consider this journey:</p><ol><li>A user opens the AI report builder.</li><li>They select a data source.</li><li>They configure report settings.</li><li>They click Generate.</li><li>The report is successfully created.</li></ol><p>If 1,000 users open the feature but only 250 generate a report, the problem may not be the feature itself. It could be the configuration process.</p><p>I added a simple funnel analyzer.</p><pre>function analyzeFunnel(events, steps) {<br>  const usersAtStep = steps.map(step =&gt; {<br>    const users = new Set(<br>      events<br>        .filter(event =&gt; event.eventName === step)<br>        .map(event =&gt; event.userId)<br>    );<br>    return users.size;<br>  });<br>  return steps.map((step, index) =&gt; {<br>    const current = usersAtStep[index];<br>    const previous = index === 0<br>      ? current<br>      : usersAtStep[index - 1];<br>    return {<br>      step,<br>      users: current,<br>      conversionRate: previous<br>        ? current / previous<br>        : 0,<br>      dropOff: previous - current<br>    };<br>  });<br>}<br>const funnel = analyzeFunnel(events, [<br>  &quot;feature_viewed&quot;,<br>  &quot;data_source_selected&quot;,<br>  &quot;settings_completed&quot;,<br>  &quot;report_generated&quot;<br>]);<br>console.table(funnel);</pre><p>The output might reveal that most users abandon the process between selecting a data source and completing their settings.</p><p>That’s a much more actionable discovery than simply saying the feature has low adoption.</p><p>One caution: this basic implementation compares unique users at each step across the full event collection. It doesn’t guarantee that the steps occurred in the correct order during the same session.</p><p>A proper funnel engine should use session IDs, timestamps, ordered event sequences, and a defined conversion window.</p><p>That is the difference between a useful prototype and trustworthy product analytics.</p><h3>9. I Added Automated Tests Before Trusting the Numbers</h3><p>Analytics calculations are deceptively easy to get wrong.</p><p>A bug in a normal interface might affect one button. A bug in an analytics calculation could make an entire product team prioritize the wrong roadmap.</p><p>I started testing the calculation engine with Node’s built-in test runner.</p><p>Create adoption.test.js:</p><pre>const test = require(&quot;node:test&quot;);<br>const assert = require(&quot;node:assert/strict&quot;);<br>const {<br>  calculateAdoption<br>} = require(&quot;./adoption&quot;);<br>test(&quot;calculates feature adoption correctly&quot;, () =&gt; {<br>  const events = [<br>    {<br>      userId: &quot;u1&quot;,<br>      eventName: &quot;feature_viewed&quot;<br>    },<br>    {<br>      userId: &quot;u1&quot;,<br>      eventName: &quot;feature_action_completed&quot;<br>    },<br>    {<br>      userId: &quot;u1&quot;,<br>      eventName: &quot;feature_reused&quot;<br>    },<br>    {<br>      userId: &quot;u2&quot;,<br>      eventName: &quot;feature_viewed&quot;<br>    }<br>  ];<br>  const eligibleUsers = [<br>    &quot;u1&quot;,<br>    &quot;u2&quot;,<br>    &quot;u3&quot;,<br>    &quot;u4&quot;<br>  ];<br>  const result = calculateAdoption(<br>    events,<br>    eligibleUsers<br>  );<br>  assert.equal(result.viewers, 2);<br>  assert.equal(result.adopters, 1);<br>  assert.equal(result.adoptionRate, 0.25);<br>  assert.equal(result.activationRate, 0.5);<br>  assert.equal(result.repeatUsageRate, 1);<br>});</pre><p>For this test, the calculation module should export its function:</p><pre>module.exports = {<br>  calculateAdoption<br>};</pre><p>Run it with:</p><pre>node --test</pre><p>I’d also test duplicate events, users with no activity, empty eligible-user lists, invalid timestamps, different workspace boundaries, and features that are only available on certain subscription plans.</p><p>The key lesson is simple: never let a dashboard’s polished appearance convince you that its underlying numbers are correct.</p><h3>10. I Turned the Prototype Into a Product Teams Could Actually Buy</h3><p>At this point, the application had a clear purpose.</p><p>It collected feature events, calculated adoption metrics, identified funnel drop-offs, and presented the results in a dashboard.</p><p>But a useful internal tool isn’t automatically a business.</p><p>I started thinking about who would pay for it.</p><p>The most promising customers would be:</p><ul><li>Early-stage SaaS companies launching new features.</li><li>Product teams struggling to understand feature adoption.</li><li>Agencies managing analytics for multiple clients.</li><li>B2B software companies trying to improve customer retention.</li><li>Founders who want product insights without hiring a dedicated analytics engineer.</li></ul><p>I would package the application as a subscription-based product called <strong>AdoptionLens</strong>.</p><p>The business model could include three plans:</p><p>PlanTarget customerPossible featuresStarterSmall SaaS teamsBasic event tracking and adoption reportsGrowthGrowing productsFunnels, segments, alerts and retention analysisAgencyMultiple client accountsSeparate workspaces, client reports and team access</p><p>These are proposed packaging tiers, not market-validated prices.</p><p>The product could eventually offer features such as:</p><ul><li>Weekly reports identifying declining feature usage.</li><li>Alerts when a previously popular feature loses adoption.</li><li>Comparisons between new and existing features.</li><li>Workspace-level adoption breakdowns.</li><li>Customer segments based on actual usage patterns.</li><li>Exportable reports for product meetings.</li></ul><p>The strongest selling point wouldn’t be another collection of charts.</p><p>It would be helping a product team decide what to improve, what to promote, and what to stop building.</p><h3>11. How I Would Run and Expand the Complete Project</h3><p>I kept the first version deliberately small so it could be developed without a complicated infrastructure setup.</p><p>A practical project structure would look like this:</p><pre>adoption-lens/<br>│<br>├── backend/<br>│   ├── server.js<br>│   ├── database.js<br>│   └── analytics.db<br>│<br>├── frontend/<br>│   ├── src/<br>│   │   ├── components/<br>│   │   │   └── AdoptionDashboard.jsx<br>│   │   ├── analytics.js<br>│   │   └── App.jsx<br>│   └── package.json<br>│<br>├── tests/<br>│   └── adoption.test.js<br>│<br>├── package.json<br>└── README.md</pre><p>For the first working version:</p><p><strong>Step 1:</strong> Create the Node.js backend and install Express, SQLite, and CORS.</p><p><strong>Step 2:</strong> Start the backend:</p><pre>node server.js</pre><p><strong>Step 3:</strong> Add the ProductAnalytics client to your frontend application.</p><p><strong>Step 4:</strong> Track meaningful feature events when users perform important actions.</p><p><strong>Step 5:</strong> Retrieve the stored events from a reporting endpoint. The prototype needs a read endpoint that returns authorized, filtered events before the dashboard can display real database data.</p><p><strong>Step 6:</strong> Run the adoption calculations and pass the resulting reports into the dashboard.</p><p><strong>Step 7:</strong> Run automated tests before using the metrics to make product decisions.</p><p>For a production release, I’d replace the SQLite prototype with PostgreSQL or an event-oriented analytics store, introduce background processing for large event volumes, and implement organization-level access control.</p><p>I’d also add event retention limits, consent-aware tracking, data deletion workflows, and aggregation rules that prevent one workspace from seeing another workspace’s activity.</p><p>The architecture should evolve with actual usage rather than becoming unnecessarily complicated on day one.</p><h3>12. The Real Opportunity Is Turning Product Activity Into Product Decisions</h3><p>The most interesting thing about building AdoptionLens wasn’t the chart or the event collector.</p><p>It was the change in the questions I could ask.</p><p>Instead of asking, “How many people clicked this feature?” I could ask:</p><ul><li>Did users successfully complete the feature’s main action?</li><li>Did they return to use it?</li><li>Which customer segment found it valuable?</li><li>Where did they abandon the experience?</li><li>Did adoption improve after we simplified the workflow?</li></ul><p>Those questions connect engineering work to business outcomes.</p><p>And that’s where a small JavaScript analytics project becomes much more valuable than a dashboard full of numbers.</p><p>A SaaS company doesn’t need another tool telling it that users are clicking buttons. It needs a system that helps it understand whether the product is becoming more useful.</p><p><strong>The best feature analytics tool doesn’t just measure what customers do. It helps a company decide what to build next.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0cf160a8dcad" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/i-built-a-javascript-tool-that-reveals-which-saas-features-customers-actually-use-0cf160a8dcad">I Built a JavaScript Tool That Reveals Which SaaS Features Customers Actually Use</a> was originally published in <a href="https://javascript.plainenglish.io">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Cut 1,000 Strings to 20 Characters With slice(). 136 Came Out Broken.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/i-cut-1-000-strings-to-20-characters-with-slice-136-came-out-broken-8bd124de66f1?source=rss----4b3a1ed4f11c---4"><img src="https://cdn-images-1.medium.com/max/1536/1*q4C18YSvLfkT3ysMvT3spA.png" width="1536"></a></p><p class="medium-feed-snippet">Emoji, accents, Hindi, Thai and Arabic through four truncation methods: the counts, the one that broke none, and its cost.</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/i-cut-1-000-strings-to-20-characters-with-slice-136-came-out-broken-8bd124de66f1?source=rss----4b3a1ed4f11c---4">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/i-cut-1-000-strings-to-20-characters-with-slice-136-came-out-broken-8bd124de66f1?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/8bd124de66f1</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[unicode]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Ferid Brković]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 18:47:20 GMT</pubDate>
            <atom:updated>2026-11-16T18:47:18.698Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Jev — A System One Classification Network by TypeSafe AI]]></title>
            <link>https://javascript.plainenglish.io/jev-a-system-one-classification-network-by-typesafe-ai-7fafa0bcb9da?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/7fafa0bcb9da</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[llm]]></category>
            <dc:creator><![CDATA[0s & 1s — All About Software ✨]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 17:01:40 GMT</pubDate>
            <atom:updated>2026-11-16T17:01:38.973Z</atom:updated>
            <content:encoded><![CDATA[<h4>Jev, Core Philosophy, Features &amp; Terminologies, Explained</h4><p><em>Greetings from the author! If this is the first story you have come across in this series, don’t miss out on the entire </em><a href="https://medium.com/@0s.and.1s/list/agentic-ai-669a20b6e38b"><em>AI Agents series </em></a><em>— explaining in great detail the core of AI agents, their communication protocols, famous frameworks, agent scaling, monitoring and observability — and a lot more. We have a great multi-part </em><a href="https://medium.com/@0s.and.1s/list/generative-ai-7dd225e7a00e"><em>Generative AI</em></a><em> series as well; don’t forget to checkout that too.</em></p><h3>Part-01: What is Jev?</h3><p>Jev is a very fast and efficient, non-generative, non-auto-regressive, schema-bound, zero-shot, multi-class classification neural network belonging to the transformer family, trained via RLCD.</p><p>Jev was intrduced in 2026 by <a href="https://typesafe.ai/">TypeSafe AI</a>.</p><h3>Part-02: The Core Philosophy of Jev</h3><p><em>— Multi-class Classification Tasks —</em></p><p>The central concept of Jev is the same as the core concept behind classification tasks in Supervised Machine Learning (SML): given a set of labelled output options, use a pre-trained model to predict what option / bucket the incoming data point falls into. If you are familiar with<a href="https://medium.com/@0s.and.1s/machine-learning-for-beginners-part-iv-supervised-machine-learning-algorithms-328f003f46f2"> classification algorithms in SML</a>, the central concept of Jev should already be very intuitive for you.</p><p>However, Jev is architecturally very, very different from Machine Learning models. This is because Jev is a Deep Learning technique; i.e., it is essentially a neural network whose architecture resembles heavily the architecture of ChatGPT-like transformer models.</p><figure><img alt="What is Jev — Jev by TypeSafe AI — 0s &amp; 1s — AI Image — Medium" src="https://cdn-images-1.medium.com/max/1024/1*0mgDYwYuEfnjD3pDvV8c2w.jpeg" /><figcaption>What is Jev — Jev by TypeSafe AI — 0s &amp; 1s — AI Image by the Author</figcaption></figure><h3>Part-03: Understanding Jev Features</h3><p>Classification was just the central idea behind Jev: the real story lies in the details. So, let’s unpack several features of Jev to understand it correctly.</p><h4>1) Non-generative</h4><p>Unlike LLMs, Jev does not generate data, i.e., it doesn’t produce massive texts, images, documents, videos or audio outputs.</p><h4>2) Non-autoregressive</h4><p>LLMs generate tokens one after the other by looping through the decoder stack automatically till ( a ) the task is complete or ( b ) the user stops the model or ( c ) max_len_output tokens have been generated. However, Jev doesn’t loop through the model to generate tokens again and again. In one go (just the prefill phase), without decoding anything, it produces the response adhering to the agreed-upon schema. In fact, it doesn’t even have a decoder stack to loop through!</p><h4>3) No Decoder Stack</h4><p>Jev is a deep neural network with multiple layers. More specifically, it is a transformer-based network that doesn’t have a decoding stack. This means it only has a pre-fill phase, and without having to loop over the model, it successfully scores the input according to the bound to the instructions and structure of the schema.</p><h4>4) Schema-bound</h4><p>Jev is schema-bound, i.e., the model takes in a strict JSON-like schema and all subsequent outputs produced by the model are mathematically guaranteed to follow that schema.</p><h4>5) Hard (Not Soft) Schemas</h4><p>LLMs can adhere to the provided schema as well, but it is not guaranteed, i.e., the LLM can hallucinate some other category even if it doesn’t exist. Moreover, LLMs don’t allow the entire behaviour to be updated at run-time, because this means any user can remove all the guardrails via single or multiple prompts to make the LLM do / generate whatever they wish to. However, Jev allows its entire taxonomy to be replaced by the user in one go, i.e., provide it the schema that it should follow and you are good to go now. Jev is mathematically guaranteed to remain within that schema.</p><h4>6) Zero-Shot Programmable</h4><p>Jev allows for guaranteed zero-shot taxonomy replacement in one prompt, i.e., you can replace the entire taxonomy or append to it without fine-tuning the model by telling the model what is safe and what is unsafe in the system prompt and it will work according to your needs to filter emails, act as a guardrail, etc. LlamaGuard and other guardrail LLMs also work like this.</p><h4>7) Excels at Semantic Classification</h4><p>Jev works the best when the given task is semantic rather than syntactic, i.e., it won’t reliably count characters or check regex patterns, but it can reliably, “logically” figure out if the action should be allowed or not.</p><blockquote>“Jev does not count reliably. This covers characters in a word, occurrences of a term in a passage, and items in a long list. The model recognizes the shape of an answer rather than tallying, and the error grows with the size of the thing being counted. Before asking a counting question, ask why the count needs a model at all. If the unit is something a regular expression or a parser can find, the count belongs in code and the model has nothing to add.” — <a href="https://docs.typesafe.ai/model-jaggedness/jev-1.13">TypeSafe Docs</a></blockquote><h4>8) Linear &amp; Non-Linear Classifier</h4><p>Jev can handle linear and non-linear tasks (both). i.e., simple tasks like <em>“is this email a spam”</em> as well as complex tasks like, <em>“is this a low-key social-engineering attempt / phishing attempt targeted at our customer support staff?” </em>In other words, Jev can capture simple and complex patterns both easily.</p><h4>9) General Classifier</h4><p>Classification techniques in SML, like logistic regression, work only for one type of a task, i.e., we train the model for one task and then get only that result in production (eg: spam vs. non-spam emails). But with Jev, one model can do multiple multi-class classification tasks. No retraining. No new dataset. Just a different output schema given to Jev which replaces the entire output taxonomy in one go so that it can label the incoming prompt properly.</p><h4>10) RLCD Training</h4><p>LLMs are trained via RLHF (Reinforcement Learning with Human Feedback) or RLVR (Reinforcement Learning with Verifiable Rewards). However, Jev is trained via RLCD (Reinforcement Learning for Calibrated Decicions). Note that in reality, Jev trains via SML techniques and is post-trained only via RLCD.</p><h3>Summary</h3><p>For quickly reviewing all the features of Jev, have a look at the following image.</p><figure><img alt="TypeSafe AI’s Jev — 0s &amp; 1s — Medium — AI Image" src="https://cdn-images-1.medium.com/max/1024/1*8o7h6XNCKHrDKYXbLiMCLA.jpeg" /><figcaption>TypeSafe AI’s Jev — 0s &amp; 1s — Medium — AI Image by the Author</figcaption></figure><p><em>Until Next Time,<br>0s &amp; 1s</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7fafa0bcb9da" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/jev-a-system-one-classification-network-by-typesafe-ai-7fafa0bcb9da">Jev — A System One Classification Network by TypeSafe AI</a> was originally published in <a href="https://javascript.plainenglish.io">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How an LLM Tokenizer Actually Works, in 71 Lines of JavaScript]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/how-an-llm-tokenizer-actually-works-in-71-lines-of-javascript-8955660cbdff?source=rss----4b3a1ed4f11c---4"><img src="https://cdn-images-1.medium.com/max/1536/1*4zI7PN3PFUBDB9MQduExzQ.png" width="1536"></a></p><p class="medium-feed-snippet">Build byte-pair encoding from scratch, train it on 225 words, and see why a short name can cost more tokens than a sentence.</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/how-an-llm-tokenizer-actually-works-in-71-lines-of-javascript-8955660cbdff?source=rss----4b3a1ed4f11c---4">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/how-an-llm-tokenizer-actually-works-in-71-lines-of-javascript-8955660cbdff?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/8955660cbdff</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ferid Brković]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 17:01:02 GMT</pubDate>
            <atom:updated>2026-11-16T17:01:01.340Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[How to Build a Postman-Like API Tester with React and TypeScript]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/how-to-build-a-postman-like-api-tester-with-react-and-typescript-ef862cc13ed2?source=rss----4b3a1ed4f11c---4"><img src="https://cdn-images-1.medium.com/max/1672/1*eaNL_DoHGGcEhQTL5myEGg.png" width="1672"></a></p><p class="medium-feed-snippet">Send GET and POST requests, inspect JSON responses, and build a useful developer tool without a heavy UI library.</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/how-to-build-a-postman-like-api-tester-with-react-and-typescript-ef862cc13ed2?source=rss----4b3a1ed4f11c---4">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/how-to-build-a-postman-like-api-tester-with-react-and-typescript-ef862cc13ed2?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/ef862cc13ed2</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Bestte]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 11:50:16 GMT</pubDate>
            <atom:updated>2026-11-16T11:50:13.865Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[JavaScript Program to Find the Sum of Odd Digits in a Number]]></title>
            <link>https://javascript.plainenglish.io/javascript-program-to-find-the-sum-of-odd-digits-in-a-number-9351d0074604?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/9351d0074604</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Vikas]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 10:07:23 GMT</pubDate>
            <atom:updated>2026-10-29T11:53:13.717Z</atom:updated>
            <content:encoded><![CDATA[<p>In JavaScript, we can find the sum of odd digits in a number by checking each digit and adding only those digits that are odd. An odd digit is a digit that is not divisible by 2, such as 1, 3, 5, 7 and 9.</p><blockquote>For example, if the given number is 1234567, its odd digits are 1, 3, 5 and 7. Therefore, the sum of odd digits is 1 + 3 + 5 + 7 = 16.</blockquote><p>In this article, we will learn different approaches to find the sum of odd digits in a number using JavaScript.</p><h4><strong>Problem Statement</strong></h4><p>Given an integer n, write a JavaScript program to calculate the sum of all odd digits present in the number.</p><h4><strong>Examples:</strong></h4><p><strong>Input:</strong></p><p>n = 1234567</p><p><strong>Output:</strong></p><p>16</p><p><strong>Explanation:</strong></p><p>The odd digits in 1234567 are 1, 3, 5 and 7.</p><p>Sum = 1 + 3 + 5 + 7 = 16.</p><h4><strong>Example 2:</strong></h4><p><strong>Input:</strong></p><p>n = 2468</p><p><strong>Output:</strong></p><p>0</p><p><strong>Explanation:</strong></p><p>The number contains only even digits. Therefore, the sum of odd digits is 0.</p><h4><strong>Example 3:</strong></h4><p><strong>Input:</strong></p><p>n = 97531</p><p><strong>Output:</strong></p><p>25</p><p><strong>Explanation:</strong></p><p>The sum of the odd digits is 9 + 7 + 5 + 3 + 1 = 25.</p><h3><strong>Approach 1: Using a While Loop</strong></h3><p>The simplest approach is to extract each digit using the remainder operator (%) and remove the last digit using integer division.</p><h4><strong>Steps:</strong></h4><ol><li>Initialize a variable sum to 0.</li><li>Convert the number to its absolute value to handle negative inputs.</li><li>Extract the last digit using n % 10.</li><li>Check whether the digit is odd using digit % 2 !== 0.</li><li>If it is odd, add it to sum.</li><li>Remove the last digit using Math.floor(n / 10).</li><li>Repeat until the number becomes 0.</li><li>Return the final sum.</li></ol><h4><strong>JavaScript Program :</strong></h4><pre>function sumOddDigits(n) {<br>n = Math.abs(n);<br>let sum = 0;<br>while (n &gt; 0) {<br>let digit = n % 10;<br>if (digit % 2 !== 0) {<br>sum += digit;<br>}<br>n = Math.floor(n / 10);<br>}<br>return sum;<br>}<br>let n = 1234567;<br>console.log(sumOddDigits(n));</pre><p><strong>Output:</strong></p><p>16</p><h3><strong>Approach 2: Using a For Loop and String Conversion</strong></h3><p>Another approach is to convert the number into a string and examine each digit individually.</p><h4><strong>Steps:</strong></h4><ol><li>Convert the absolute value of the number into a string.</li><li>Initialize sum to 0.</li><li>Iterate through each character of the string.</li><li>Convert the character into a number.</li><li>If the digit is odd, add it to sum.</li><li>Print the final sum.</li></ol><h4><strong>JavaScript Program :</strong></h4><pre>function sumOddDigits(n) {<br>let digits = String(Math.abs(n));<br>let sum = 0;<br>for (let i = 0; i &lt; digits.length; i++) {<br>let digit = Number(digits[i]);<br>if (digit % 2 !== 0) {<br>sum += digit;<br>}<br>}<br>return sum;<br>}<br>let n = 1234567;<br>console.log(sumOddDigits(n));</pre><p><strong>Output:</strong></p><p>16</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9351d0074604" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/javascript-program-to-find-the-sum-of-odd-digits-in-a-number-9351d0074604">JavaScript Program to Find the Sum of Odd Digits in a Number</a> was originally published in <a href="https://javascript.plainenglish.io">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Program to Find the Sum of the First and Last Digits of a Number]]></title>
            <link>https://javascript.plainenglish.io/javascript-program-to-find-the-sum-of-the-first-and-last-digits-of-a-number-ffc13d435140?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/ffc13d435140</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Vikas]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 10:07:20 GMT</pubDate>
            <atom:updated>2026-10-29T11:52:54.290Z</atom:updated>
            <content:encoded><![CDATA[<p>In JavaScript, we can find the sum of the first and last digits of a number using arithmetic operators, loops and string methods. This is a common programming problem for beginners who want to understand number manipulation in JavaScript.</p><blockquote>For example, if the given number is 12345, the first digit is 1 and the last digit is 5. Their sum is 1 + 5 = 6.</blockquote><p>In this article, we will learn different methods to find the sum of the first and last digits of a number in JavaScript with examples.</p><h4><strong>Problem Statement</strong></h4><p>Given a positive integer n, find the sum of its first and last digits.</p><h4><strong>Example 1:</strong></h4><h4>Input:</h4><p>n = 12345</p><h4>Output:</h4><p>6</p><p><strong>Explanation:</strong> The first digit is 1 and the last digit is 5. Therefore, the sum is 1 + 5 = 6.</p><h4><strong>Example 2:</strong></h4><h4>Input:</h4><p>n = 9876</p><h4>Output:</h4><p>15</p><p><strong>Explanation:</strong> The first digit is 9 and the last digit is 6. Therefore, the sum is 9 + 6 = 15.</p><h4><strong>Example 3:</strong></h4><h4>Input:</h4><p>n = 7</p><h4>Output:</h4><p>14</p><p><strong>Explanation:</strong> Since the number contains only one digit, it is both the first and last digit. Therefore, the sum is 7 + 7 = 14.</p><h3><strong>Approach 1: Using a String</strong></h3><p>The simplest approach is to convert the number into a string and access its first and last characters using their indexes.</p><h4><strong>Steps :</strong></h4><ol><li>Convert the number into a string using String().</li><li>Access the first digit using index 0.</li><li>Access the last digit using length — 1.</li><li>Convert both characters into numbers using Number().</li><li>Add the two digits and display the result.</li></ol><h4><strong>JavaScript Program :</strong></h4><pre>function sumFirstLastDigits(n) {<br>// Convert the number into a string<br>const str = String(Math.abs(n));<br>// Get the first and last digits<br>const firstDigit = Number(str[0]);<br>const lastDigit = Number(str[str.length - 1]);<br>// Return their sum<br>return firstDigit + lastDigit;<br>}<br>const n = 12345;<br>console.log(&quot;Number:&quot;, n);<br>console.log(&quot;Sum of first and last digits:&quot;,<br>sumFirstLastDigits(n));</pre><p><strong>Output :</strong></p><p>Number: 12345</p><p>Sum of first and last digits: 6</p><h3><strong>Approach 2: Using Arithmetic Operators</strong></h3><p>We can also solve this problem using arithmetic operators without converting the number into a string.</p><h4><strong>Steps :</strong></h4><ol><li>Find the last digit using the modulo operator %.</li><li>Remove the last digit using Math.floor(n / 10).</li><li>Repeat the division until only the first digit remains.</li><li>Add the first and last digits.</li></ol><h4><strong>JavaScript Program :</strong></h4><pre>function sumFirstLastDigits(n) {<br>n = Math.abs(n);<br>// Find the last digit<br>const lastDigit = n % 10;<br>// Find the first digit<br>let firstDigit = n;<br>while (firstDigit &gt;= 10) {<br>firstDigit = Math.floor(firstDigit / 10);<br>}<br>// Return the sum<br>return firstDigit + lastDigit;<br>}<br>const n = 12345;<br>console.log(&quot;Number:&quot;, n);<br>console.log(&quot;Sum of first and last digits:&quot;,<br>sumFirstLastDigits(n));</pre><p><strong>Output :</strong></p><p>Number: 12345</p><p>Sum of first and last digits: 6</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ffc13d435140" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/javascript-program-to-find-the-sum-of-the-first-and-last-digits-of-a-number-ffc13d435140">JavaScript Program to Find the Sum of the First and Last Digits of a Number</a> was originally published in <a href="https://javascript.plainenglish.io">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JavaScript Program to Convert Binary to Octal]]></title>
            <link>https://javascript.plainenglish.io/javascript-program-to-convert-binary-to-octal-bfd496a679f4?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/bfd496a679f4</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Vikas]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 10:07:17 GMT</pubDate>
            <atom:updated>2026-10-29T11:52:34.462Z</atom:updated>
            <content:encoded><![CDATA[<p>In JavaScript, converting a binary number to an octal number is a common programming problem for beginners. Binary numbers use only two digits, 0 and 1, while octal numbers use digits from 0 to 7.</p><blockquote>JavaScript provides built-in methods such as parseInt() and toString() to convert numbers between different number systems.</blockquote><p>In this article, we will learn different methods to convert a binary number to an octal number in JavaScript with examples.</p><h3><strong>What Is Binary to Octal Conversion?</strong></h3><p><strong>Binary number system:</strong> The binary number system has a base of 2 and uses only the digits 0 and 1.</p><p><strong>Octal number system:</strong> The octal number system has a base of 8 and uses digits from 0 to 7.</p><blockquote>For <strong>example:</strong></blockquote><blockquote>Binary number: 110101</blockquote><blockquote>Decimal equivalent: 53</blockquote><blockquote>Octal equivalent: 65</blockquote><p>Therefore, the binary number 110101 is equal to the octal number 65.</p><h4><strong>Problem Statement</strong></h4><p>Given a binary number as a string, convert it into its equivalent octal number using JavaScript.</p><h4><strong>Example 1:</strong></h4><p><strong>Input:</strong></p><p>Binary = “110101”</p><p><strong>Output:</strong></p><p>Octal = 65</p><h4><strong>Example 2:</strong></h4><p><strong>Input</strong>:</p><p>Binary = “1010”</p><p><strong>Output</strong>:</p><p>Octal = 12</p><h3><strong>Approach 1: Using parseInt() and toString()</strong></h3><p>The simplest way to convert a binary number to an octal number in JavaScript is to use the built-in parseInt() and toString() methods.</p><h4><strong>Steps :</strong></h4><ol><li>Store the binary number as a string.</li><li>Use parseInt(binary, 2) to convert the binary string into a decimal number.</li><li>Use toString(8) to convert the decimal number into an octal string.</li><li>Print the result.</li></ol><h4><strong>JavaScript Program :</strong></h4><pre>// JavaScript program to convert binary to octal<br>function binaryToOctal(binary) {<br>// Validate the binary string<br>if (!/^[01]+$/.test(binary)) {<br>return &quot;Invalid binary number&quot;;<br>}<br>// Convert binary to decimal<br>let decimal = parseInt(binary, 2);<br>// Convert decimal to octal<br>let octal = decimal.toString(8);<br>return octal;<br>}<br>// Example<br>let binary = &quot;110101&quot;;<br>console.log(&quot;Binary number:&quot;, binary);<br>console.log(&quot;Octal number:&quot;, binaryToOctal(binary));</pre><p><strong>Output :</strong></p><p>Binary number: 110101</p><p>Octal number: 65</p><h3><strong>Approach 2: Using BigInt for Large Binary Numbers</strong></h3><p>When the binary number contains many digits, BigInt can be used to avoid the precision limitations of ordinary JavaScript numbers.</p><h4><strong>JavaScript Program :</strong></h4><pre>// JavaScript program to convert a large binary number to octal<br>function binaryToOctal(binary) {<br>// Validate the binary string<br>if (!/^[01]+$/.test(binary)) {<br>return &quot;Invalid binary number&quot;;<br>}<br>// Convert binary to BigInt<br>let decimal = BigInt(&quot;0b&quot; + binary);<br>// Convert BigInt to octal<br>return decimal.toString(8);<br>}<br>// Example<br>let binary = &quot;110101&quot;;<br>console.log(&quot;Binary number:&quot;, binary);<br>console.log(&quot;Octal number:&quot;, binaryToOctal(binary));</pre><p><strong>Output</strong></p><p>Binary number: 110101</p><p>Octal number: 65</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfd496a679f4" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/javascript-program-to-convert-binary-to-octal-bfd496a679f4">JavaScript Program to Convert Binary to Octal</a> was originally published in <a href="https://javascript.plainenglish.io">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Which AI Model Does What? One Ticket, Five Decisions]]></title>
            <link>https://javascript.plainenglish.io/which-ai-model-does-what-one-ticket-five-decisions-c0c8755af508?source=rss----4b3a1ed4f11c---4</link>
            <guid isPermaLink="false">https://medium.com/p/c0c8755af508</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Shahadath Hossen Sajib]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 10:06:53 GMT</pubDate>
            <atom:updated>2026-11-13T09:27:16.556Z</atom:updated>
            <content:encoded><![CDATA[<h4>A backend engineer’s guide to the AI toolbox: LLMs, SLMs, embeddings, VLMs, and the boring classifiers, with real latency and cost numbers from one real pipeline.</h4><figure><img alt="Cover infographic: the AI toolbox sketched as four shelves. Language holds LLMs, SLMs, embeddings and rerankers. Vision holds VLMs and OCR. Audio holds STT and TTS. Classic ML holds classifiers and forecasting" src="https://cdn-images-1.medium.com/max/1024/1*iJSQcmTLuBwfPQVybTCqBQ.png" /><figcaption><em>The AI toolbox: four shelves, one ticket, five decisions.</em></figcaption></figure><p>Every article about AI models starts with a taxonomy. LLMs, SLMs, embeddings, VLMs, OCR, STT, TTS, MoE. Memorize these ten terms, and you’re somehow ready.</p><p>You’re not.</p><p>When you build a real feature, the taxonomy never appears on screen. What appears is a request, a deadline, and a bill. The actual skill is looking at one incoming request and answering two questions: which model does this job, and what does that choice cost me?</p><p>So instead of another taxonomy, here’s one real system with five decisions in it. A support-ticket pipeline. Nothing exotic. It’s the kind of feature half the SaaS world is building right now.</p><h3><strong>The Four Shelves (30-Second Version)</strong></h3><p>You do need the map, just not a lecture. Almost every AI model sits on one of four shelves:</p><ul><li><strong>Language</strong> reads and writes text: LLMs (big, general), SLMs (small, fast), embeddings (meaning as vectors), rerankers (second-opinion ranking)</li><li><strong>Vision</strong> reads and understands images: OCR extracts the words, VLMs reason about what they see</li><li><strong>Audio</strong> hears and speaks: STT, TTS, speaker diarization</li><li><strong>Classic ML</strong> skips the model drama entirely: classification, forecasting, recommendations. Boring, fast, and quietly running half the economy</li></ul><p>Every AI feature you’ll ever build combines these. Now the pipeline.</p><figure><img alt="Flowchart sketch of a support ticket flowing through model decisions: classify with an SLM in 50 ms, find similar tickets with embeddings in 20 ms, draft the reply with an LLM in 1 to 3 seconds, with a VLM side branch for invoice photos" src="https://cdn-images-1.medium.com/max/1024/1*-HGnmbfjWvUrfK55kbYQwg.png" /><figcaption><em>One ticket, five decisions: each step is a model choice with its own latency and cost.</em></figcaption></figure><h3>Decision 1: What Is This Ticket Even About?</h3><p>100,000 tickets a month, three categories: billing, technical, other.</p><p>This is not a reasoning problem. This is a sorting problem that existed for twenty years before LLMs, and a small classifier or tiny SLM solves it in <strong>under 50 milliseconds</strong> for a rounding error of a cost.</p><p>Reaching for a frontier model here isn’t sophistication. It’s a tax. The boring shelf wins, and it wins by a mile.</p><h3>Decision 2: Has Anyone Seen This Before?</h3><p>Half of support tickets are repeats. Before drafting anything new, search your history: embeddings turn the ticket into a vector, vector search pulls back the three most similar past tickets and their resolutions.</p><p>Latency: about 20 ms. Cost: fractions of a cent per thousand queries. And the reply quality jump is the single biggest win in this whole pipeline, because the LLM stops guessing your product’s policies and starts repeating them.</p><h3>Decision 3: Draft the Reply</h3><p>Now, and only now, the LLM. It gets the ticket, the three similar cases, and a short policy snippet, and writes the draft.</p><p>This is the one step that genuinely needs a large model: open-ended, language-shaped, no fixed categories. Latency is real, 1 to 3 seconds, but it’s async background work, so nobody stares at a spinner.</p><h3>Decision 4: What If There’s an Invoice Attached?</h3><p>If the ticket contains a photo, an invoice, or a screenshot, plain OCR can extract the text, but it extracts <em>words</em>, not <em>meaning</em>. A VLM can answer “what’s the total amount payable?” directly, because it reasons about layout, not just characters.</p><p>Use it only when layout understanding matters. It costs more than OCR, and you don’t need it for plain text.</p><h3>Decision 5: Should It Talk?</h3><p>Only if it’s a voice product: STT in, TTS out, around the same LLM. Great feature, real latency engineering, and completely skippable for most backends. Knowing you can skip a shelf is half the skill.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9r6r6HtTUhwHocDkT8tjNw.png" /><figcaption><em>The cost of reaching for the LLM: green for the boring shelf, yellow for the workhorses, red for where you spend on purpose.</em></figcaption></figure><h3>What to Learn First</h3><p>The same three things every serious guide converges on, because they’re true:</p><ol><li><strong>LLMs + structured output.</strong> Reliable JSON beats beautiful prose</li><li><strong>Embeddings + retrieval.</strong> The cheapest quality jump in AI engineering</li><li><strong>Tool calling.</strong> Where a model stops answering and starts working</li></ol><p>VLMs, voice, agents: add each one the day your problem demands it, not before.</p><h3>The Whole Point</h3><p>Articles about AI models tell you what exists. Engineering is choosing: one request, one bill, one decision at a time.</p><p>So the next time you reach for the biggest model on the shelf, ask the only question that matters. <strong>Which decision is this actually making?</strong></p><p>Sometimes the answer is the LLM. More often than the internet admits, it’s the boring classifier, and it finishes before the LLM has read the prompt.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0c8755af508" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/which-ai-model-does-what-one-ticket-five-decisions-c0c8755af508">Which AI Model Does What? One Ticket, Five Decisions</a> was originally published in <a href="https://javascript.plainenglish.io">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>