<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jeremy Rivera on Medium]]></title>
        <description><![CDATA[Stories by Jeremy Rivera on Medium]]></description>
        <link>https://medium.com/@jeremy-rivera?source=rss-68b60f6c2c38------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*xZ7OjM6hyn946sou-GFZ0Q.png</url>
            <title>Stories by Jeremy Rivera on Medium</title>
            <link>https://medium.com/@jeremy-rivera?source=rss-68b60f6c2c38------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 03:37:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jeremy-rivera/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[Why is prompt eval needed and what are some open-source options to do it?]]></title>
            <link>https://jeremy-rivera.medium.com/why-is-prompt-eval-needed-and-what-are-some-open-source-options-to-do-it-285d5d75d601?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/285d5d75d601</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 16 Sep 2025 13:27:43 GMT</pubDate>
            <atom:updated>2025-09-16T13:27:43.688Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Complex geometric shape, a metaphor for evaluation and AI" src="https://cdn-images-1.medium.com/max/1024/0*HWIP5UWOMofj6s2A" /></figure><p>Prompt evaluation is a critical step in developing effective LLM applications. It ensures that prompts produce accurate, relevant, and unbiased outputs, improving user experience and reducing the risk of ‘hallucination’ or misinformation. As LLMs become increasingly integrated into workflows, reliable prompt evaluation becomes essential for maintaining high-quality performance and reducing operational costs.</p><p><a href="https://www.nature.com/articles/s41537-023-00379-4">This article</a> briefly encapsulates many of the flaws with viewing responses from GPTs as truth. Many models ‘hallucinate’ and even present misinformation, sometimes with dubious consequences. <a href="https://www.forbes.com/sites/mollybohannon/2023/06/08/lawyer-used-chatgpt-in-court-and-cited-fake-cases-a-judge-is-considering-sanctions/">We read in another article</a> of a situation in which a lawyer cited several cases he found on ChatGPT it was discovered that the cases he used were completely fabricated by the LLM.</p><p>Scenarios such as these present the importance of Prompt evaluation. Improving accuracy through rigorous quality assurance routines help maintain the validity of a model’s responses, thereby increasing the production of high-quality and relevant outputs.</p><p>On top of quality assurance, there must be a focus on the performance and efficiency of an LLM. The identification and refining of accurate prompts increase throughput and decrease response times from the model, lowering periods of undesired latency. This encourages the efficient use of resources that could significantly lower costs for the providers of the LLM.</p><p>What also needs to be considered is the potential for bias. When a user of a GPT or LLM queries information, it is imperative that what is returned is presented with neutrality and not enforcing potentially offensive stereotypes or misinformation. Having a thorough evaluation process will ultimately enhance overall user experience, leading to better session with the model.</p><p><strong>Open Source Tools for Prompt Evaluation</strong></p><p>There are several open-source tools crafted to facilitate LLM output.</p><p><a href="https://github.com/openai/evals">OpenAI Eval Toolkit</a>:Provides developers with a toolkit to create custom prompt evaluations. It offers quick testing and feedback loops to refine model outputs.</p><pre>import openai<br>import openai_eval<br># Define a custom evaluation<br>def custom_eval(prompt):<br> model = &quot;gpt-3.5-turbo&quot;<br> response = openai_eval.run_eval(model, prompt)<br> return response<br># Example prompt<br>prompt = &quot;What is the capital of France?&quot;<br>result = custom_eval(prompt)<br>print(f&quot;Model response: {result}&quot;)</pre><p><a href="https://www.langchain.com/">LangChain</a>:A powerful tool for chaining prompts and improving workflows. It allows developers to evaluate and adjust LLM outputs across various stages.</p><pre>from langchain.prompts import PromptTemplate<br>from langchain.chains import LLMChain<br>from langchain.llms import OpenAI<br># Define the prompt template<br>template = &quot;What are the top 3 use cases for {technology}?&quot;<br>prompt = PromptTemplate(input_variables=[&quot;technology&quot;], template=template)<br># Chain the LLM to process the prompt<br>llm = OpenAI(model_name=&quot;text-davinci-003&quot;)<br>llm_chain = LLMChain(prompt=prompt, llm=llm)<br># Run the evaluation<br>response = llm_chain.run(technology=&quot;AI in healthcare&quot;)<br>print(response)</pre><p><a href="https://huggingface.co/">Hugging Face</a>’s Evaluate Library: Seamlessly integrates with the transformers library, automating and standardizing prompt evaluations. It provides a versatile approach for developers to analyze and improve model outputs.</p><pre>from transformers import pipeline<br>from evaluate import evaluator<br># Load the model<br>classifier = pipeline(&quot;sentiment-analysis&quot;)<br># Define the evaluation<br>eval = evaluator(&quot;text-classification&quot;)<br>results = eval.compute(<br> model_or_pipeline=classifier,<br> data=[{&quot;text&quot;: &quot;I love AI tools!&quot;}],<br>)<br>print(f&quot;Evaluation results: {results}&quot;)</pre><p><strong>The Future of Prompt Evaluation &amp; Integrating it into Your Workflow</strong></p><p>Artificial Intelligence isn’t going anywhere. These systems are going to continue to progress and evolve and as they do, prompt evaluation is only going to play a more pivotal role in the evolution of LLMs. Users can expect advances in response validity and reduction of bias, thereby causing daily adoption to continue to increase.</p><p>Tools like <a href="https://kusho.ai/">KushoAI</a> are revolutionizing the testing landscape by automating the creation of API tests, enabling faster software releases with fewer bugs. KushoAI integrates seamlessly with Continuous Integration platforms, providing real-time test updates and ensuring up-to-date coverage as codebases evolve. This allows engineering teams to accelerate deployment and focus on innovating, not debugging.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=285d5d75d601" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why is the white house urging developers to use memory safe languages like rust to reduce bugs]]></title>
            <link>https://jeremy-rivera.medium.com/why-is-the-white-house-urging-developers-to-use-memory-safe-languages-like-rust-to-reduce-bugs-cf157d465864?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/cf157d465864</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[rust]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 02 Sep 2025 13:31:30 GMT</pubDate>
            <atom:updated>2025-09-02T13:31:30.907Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="The white house and lawn" src="https://cdn-images-1.medium.com/max/1024/0*HnQ2CUr52gQFDt2t" /></figure><p>Working primarily with Python and JavaScript, I hadn’t had to worry much about low-level memory issues. Yet recently I encountered why memory safety is becoming such a priority and what it means for developers across all languages.</p><p>The White House issued a call for software developers and technology companies to embrace memory-safe programming languages, like Rust, as part of a broad strategy to secure the digital ecosystem. In a recent report titled “<a href="https://www.whitehouse.gov/wp-content/uploads/2024/02/Final-ONCD-Technical-Report.pdf">Back to the Building Blocks: A Path Toward Secure and Measurable Software,</a>” the Office of the National Cyber Director (<strong>ONCD</strong>) highlighted memory safety vulnerabilities as a persistent but preventable root cause of many of the most devastating cyber incidents over the past few decades. From infamous exploits like the <a href="https://www.cisa.gov/news-events/alerts/2014/04/08/openssl-heartbleed-vulnerability-cve-2014-0160">Heartbleed vulnerability</a> to more recent events like the <a href="https://citizenlab.ca/2023/09/blastpass-nso-group-iphone-zero-click-zero-day-exploit-captured-in-the-wild/">Blastpass exploit in 2023</a>, memory-related flaws have proven to be a consistent security risk that affects everyone from individual users to national institutions.</p><p>This report, was aimed at engineers and technical leaders, outlining how the adoption of memory-safe languages (such as Rust) can significantly reduce the attack surface, potentially reducing entire classes of vulnerabilities. But what exactly does it mean for a language to be “<em>memory safe</em>,” and why has the US Government made this recommendation?</p><h3>Understanding Memory Safety</h3><p>Memory safety refers to the ability of a language to prevent common programming errors that can lead to security vulnerabilities. Many programming languages — especially those historically popular for system-level programming like C and C++ — are not memory safe. They allow developers to access memory directly and can make it easy to accidentally overwrite critical data or execute code from unintended locations. Such vulnerabilities open up systems to a host of attacks, like buffer overflows and memory leaks, which users with malicious intent will often exploit to gain unauthorized access, escalate privileges, or crash systems.</p><p>Memory-safe languages, typically, prevent these issues by design. Languages like Rust and, to a lesser extent, Java, Go, and Swift, were designed to prevent unsafe memory access. Rust, in particular, has been gaining traction because its unique approach to memory management allows high-performance and low-level programming without the pitfalls of the C family of languages. Rust enforces memory safety through strict compile-time checks, removing the possibility of buffer overflows, use-after-free bugs, and null pointer dereferencing, all which are common culprits in security vulnerabilities.</p><h3>Why Memory Safety Matters Now</h3><p>The White House’s push for memory safety is rooted in the recognition that the stakes for software vulnerabilities have never been higher. Digital systems are now deeply embedded in national infrastructure, from healthcare to finance to national security. As cyber threats <a href="https://www.csis.org/programs/strategic-technologies-program/significant-cyber-incidents">evolve in scale and sophistication</a>, even a single memory safety flaw can lead to widespread disruptions and damages.</p><p>For us engineers and cybersecurity professionals, memory safety has tangible benefits beyond security. By enforcing stricter memory access rules at the language level, memory-safe languages reduce the number of runtime errors and bugs in production environments. This can lead to fewer critical bugs crawling into production, improving overall software quality and reducing the time spent on debugging and patching. Rust is increasingly being used in projects that prioritize both performance and safety, from web browsers like Firefox to components of major operating systems like Windows and Linux.</p><h3>Shifting Responsibility for Cybersecurity</h3><p>One of the most notable points in the <strong>ONCD</strong> report is a shift in responsibility for cybersecurity from individual users and small businesses to technology creators and large organizations. Instead of leaving end-users and small enterprises to bear the burden of cybersecurity, the report calls on the actual developers and larger tech companies to integrate security at the design and development stages.</p><figure><img alt="AI generated Rust logo" src="https://cdn-images-1.medium.com/max/1024/0*UvfAhjyFl7zr-xSq" /></figure><h3>Moving Forward with Memory-Safe Languages</h3><p>The White House’s recommendation signals a strong support for memory safety as a foundational principle in software development. For development and testing teams, this translates to a call to embrace languages that make secure programming practices the default. The push toward memory safety also aligns with broader “secure by design” principles, where security is considered at inception, and then at every other stage of development.</p><p>As the industry increasingly adopts memory-safe languages, now is an ideal time for software engineers, quality assurance teams, and software development engineers in test (SDETs) to consider using these languages into their applications and systems. While transitioning to another language requires effort and may involve overcoming initial learning curves, the long-term security and quality benefits make it an investment worth considering. For software teams, memory-safe language use is not just about mitigating risks; it’s about building a more secure, resilient, and trustworthy systems, leading to improved performance and safer outcomes.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cf157d465864" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What strategies do you use for cache invalidation?]]></title>
            <link>https://jeremy-rivera.medium.com/what-strategies-do-you-use-for-cache-invalidation-d05b56ae2921?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/d05b56ae2921</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[caching]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 02 Sep 2025 13:21:29 GMT</pubDate>
            <atom:updated>2025-09-02T13:21:29.377Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Three locks in ascending sizes" src="https://cdn-images-1.medium.com/max/1024/0*LG8FTH7BliYqWV57" /></figure><p>They say that there are only two hard things in Computer Science: Cache Invalidation and naming things. Caching improves application speed by storing data locally, but it requires cache invalidation strategies to keep data accurate as changes occur. Let’s explore why cache invalidation is important and examine some effective strategies.</p><h4>Why Is Cache Invalidation Needed?</h4><p>Caches reduce the need to access slower data stores, improving speed and reducing server load. However, cached data can become outdated. Without invalidation, users might see stale data, leading to inconsistencies, security risks, and inefficient resource use.</p><h4>Common Cache Invalidation Strategies</h4><ol><li><strong>Time-Based Expiry (TTL)<br></strong>In a time-to-live (TTL) strategy, cached data expires after a defined interval, removing or refreshing old data automatically. TTL is simple to set up and is useful when data freshness isn’t critical but periodic updates are necessary.<br><strong>Example</strong>: A weather app could cache forecast data every 30 minutes, ensuring users see current information without frequent API calls.<br><strong>Best Use</strong>: TTL is suited for data with predictable update intervals, such as metrics, weather data, or static website content.</li><li><strong>Manual Invalidation<br></strong>In manual invalidation, developers or applications trigger cache invalidation directly when data changes, providing precise control over cache contents.<br><strong>Example</strong>: An e-commerce platform can invalidate a cached product entry when the product’s price or availability changes, ensuring users see correct details.<br><strong>Best Use</strong>: Ideal for infrequent but critical updates, like pricing data, configurations, or content management systems (CMS).</li><li><strong>Write-Through Cache<br></strong>A write-through cache updates both the cache and database on any data modification, keeping the cache in sync with real-time changes.<br><strong>Example</strong>: A banking app could use write-through caching for account balances, preventing users from seeing outdated information after transactions.<br><strong>Best Use</strong>: Effective for frequently read-and-updated data, such as user profiles, financial records, or configuration data.</li><li><strong>Cache-Aside (Lazy Loading)<br></strong>With cache-aside, or lazy loading, data is cached only upon request. If the data is absent in the cache (a “cache miss”), it is fetched from the database, cached, and returned to the requester.<br><strong>Example</strong>: A blog application could cache articles on the first read, reducing database calls on future requests.<br><strong>Best Use</strong>: This method is best for data accessed sporadically, like blog articles or user-generated content that doesn’t change often.</li><li><strong>Event-Driven Invalidation<br></strong>Event-driven invalidation uses data updates as triggers for invalidating related cache entries. It’s a popular strategy in distributed systems or microservices architectures.<br><strong>Example</strong>: In a retail platform, a product update event might invalidate the product’s cache across multiple services, ensuring all views reflect the update immediately.<br><strong>Best Use</strong>: Ideal for applications that need real-time updates, such as collaborative tools or data-sensitive applications with dependencies on other services.</li><li><strong>Versioned Cache Entries<br></strong>With versioning, cache entries are tagged with a version number that increments with each data update. Outdated versions are then discarded.<br><strong>Example</strong>: A documentation website could serve different versions of a guide, allowing users to access specific versions while seeing the most recent updates.<br><strong>Best Use</strong>: Ideal for data with multiple versions or where backwards compatibility matters, like API documentation or CMS content.</li></ol><h4>Choosing the Right Strategy</h4><p>When choosing a cache invalidation strategy, consider your data’s update frequency, criticality, and access patterns. For example, finance and e-commerce platforms benefit from real-time cache updates (e.g., write-through or event-driven invalidation), while content-heavy sites can often rely on TTL or cache-aside.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d05b56ae2921" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is WSGI? Why is this needed for running apps in production?]]></title>
            <link>https://jeremy-rivera.medium.com/what-is-wsgi-why-is-this-needed-for-running-apps-in-production-7d6698c0b195?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d6698c0b195</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[app-development]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 26 Aug 2025 13:21:41 GMT</pubDate>
            <atom:updated>2025-08-26T13:21:41.843Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Man holding up a sticky note with ‘Python’ on it" src="https://cdn-images-1.medium.com/max/1024/0*05p_R-MAY4ZC0ZNb" /></figure><p><strong>What is WSGI?</strong></p><p>As a web developer doing much more work with Python, I’ve recently found deployment trickier, especially when it comes to making sure my web applications run smoothly. When I first encountered <strong>WSGI </strong>(Web Server Gateway Interface), I realized it was a key piece of the puzzle.</p><p>WSGI is a specification that defines a standard interface between web servers and Python web applications or frameworks (<em>WSGI is a Python standard described in detail in </em><a href="https://peps.python.org/pep-3333/"><strong><em>PEP 3333</em></strong></a>). It serves as a bridge, allowing for communication between a web server (like Nginx or Apache) and Python applications, enabling developers to build scalable and efficient web apps.</p><p>WSGI is crucial because it standardizes the way web applications communicate with servers, allowing devs to switch between different web servers and frameworks without changing the application code. This flexibility is especially important in production environments, where different servers might be used for handling requests, load balancing, and deploying applications.</p><p><strong>How does WSGI work?</strong></p><p>When a WSGI server receives a client request, it forwards the request to the application and then sends the response back to the client, acting solely as a conduit. The server itself does not perform any additional processing; all the application logic must be handled by the application or middleware. While the WSGI specification is not necessary for building applications using various frameworks or toolkits, if middleware is not already integrated into the framework or a wrapper isn’t provided for external middleware, developers must know how to effectively stack it with their application to ensure proper functionality and communication.</p><p><strong>Why is WSGI Needed for Running Apps in Production?</strong></p><ol><li><strong>Interoperability</strong>: WSGI enables different web servers and Python applications to work together seamlessly. This allows developers to choose the best tools for their needs without worrying about compatibility issues.</li><li><strong>Scalability</strong>: By standardizing the interface, WSGI makes it easier to scale applications. Developers can use different servers and middleware to handle increased load without modifying their application code.</li><li><strong>Performance</strong>: WSGI allows applications to serve multiple requests concurrently, which is essential for high-traffic environments. This can significantly improve the performance of web applications.</li><li><strong>Flexibility</strong>: WSGI supports various deployment options, including serving applications directly from a server or behind a reverse proxy. This flexibility is vital for production setups, where different architectures may be used.</li></ol><p><strong>Popular WSGI Servers and Usage Examples:</strong></p><p><strong>Gunicorn</strong> (Green Unicorn): A popular WSGI server for deploying Python applications. It is known for its simplicity and ability to handle concurrent requests efficiently.</p><pre>gunicorn myapp:app</pre><ul><li>Here, myapp is the name of the Python file (without the .py extension) and app is the WSGI application callable.</li></ul><p><strong>Uvicorn: </strong>An ASGI server that can also run WSGI applications. It’s particularly well-suited for asynchronous applications and frameworks like FastAPI and Starlette.</p><pre>uvicorn myapp:app - host 0.0.0.0 - port 8000</pre><ul><li>Similar to Gunicorn, myapp is the file name, and app is the callable.</li></ul><p><strong>PM2</strong> (Process Manager 2): A popular process manager for Node.js applications that can also manage Python applications via a WSGI server. It allows for easy process management, monitoring, and automatic restarts.</p><p>This command starts Gunicorn using PM2 to manage the application, allowing for easy monitoring and management.</p><pre>pm2 start gunicorn - name myapp - myapp:app</pre><p>By leveraging WSGI and these popular servers, developers can ensure that their Python applications are well-equipped to handle production demands efficiently and reliably.</p><p>For more details on WSGI, you can check out resources like<a href="https://www.python.org/dev/peps/pep-0333/"> Python’s official WSGI documentation</a><strong>.</strong></p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d6698c0b195" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is htmx and why is it relevant?]]></title>
            <link>https://jeremy-rivera.medium.com/what-is-htmx-and-why-is-it-relevant-1ecd7cbf843b?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ecd7cbf843b</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 19 Aug 2025 13:17:55 GMT</pubDate>
            <atom:updated>2025-08-19T13:17:55.105Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Web development books" src="https://cdn-images-1.medium.com/max/1024/0*LHasjM9paZsvoNLz" /></figure><p>I started my tech career as a <em>MERN</em> (MongoDB, ExpressJS, React, NodeJS) web application developer. The modern web development stack consists of a minimum of HTML (<em>Hypertext markup language</em>), CSS (<em>Cascading style sheets</em>), and Javascript. Every web page has HTML as the skeleton (<em>The Document Object Model</em>), CSS as its skin, and Javascript doing most of the heavy lifting. Because these technologies are the bread and butter of web development, several new and exciting libraries make programming with these tools refreshing. I heard some buzz regarding <strong>htmx</strong> and decided to check it out.</p><p><strong>htmx</strong> is a lightweight JavaScript library that allows developers to create dynamic web applications by extending HTML’s capabilities. It enables developers to use HTML attributes to define how a page should behave, facilitating async requests, partial page updates, and other interactive features without relying heavily on other JavaScript [JS] libraries and frameworks.</p><h3>Relevance of htmx:</h3><ol><li><strong>Simplicity and Usability</strong>: htmx allows developers to achieve complex interactions with minimal JavaScript. This simplicity can be particularly appealing for projects where a full-fledged front-end framework may be overkill (<em>overengineering a webpage is a common crux of web developers</em>). Developers can add interactivity directly within the HTML document, making it easier to maintain and understand.</li><li><strong>Progressive Enhancement</strong>: It promotes a progressive enhancement approach, allowing developers to enhance existing HTML applications gradually without requiring a complete rewrite or a deep understanding of the various different popular JavaScript libraries and frameworks(<em>think React, Angular, Vue, Svelte, etc</em>). This approach ensures that applications remain functional even if JavaScript is disabled.</li><li><strong>Improved Performance</strong>: By enabling partial page updates and reducing the amount of JavaScript needed, htmx can lead to improved performance. Developers load only the necessary content when needed, which can result in faster page loads and a smoother user experience.</li><li><strong>Server-Side Integration</strong>: htmx works well with server-side technologies, allowing developers to leverage server-rendered HTML efficiently. This integration is especially useful for traditional web applications that rely on server-side rendering.</li><li><strong>Community and Ecosystem</strong>: As htmx gains popularity, it is becoming part of a broader ecosystem that includes other tools and libraries, enabling developers to build modern web applications more effectively without the complexity of larger frameworks.</li></ol><p>Quick Start [<em>from: </em><a href="https://htmx.org/"><em>https://htmx.org/</em></a>]</p><pre>&lt;script src=&quot;https://unpkg.com/htmx.org@2.0.3&quot;&gt;&lt;/script&gt;<br> &lt;! - have a button POST a click via AJAX →<br> &lt;button hx-post=&quot;/clicked&quot; hx-swap=&quot;outerHTML&quot;&gt;<br> Click Me<br> &lt;/button&gt;</pre><p>The <a href="https://htmx.org/attributes/hx-post/">hx-post</a> and <a href="https://htmx.org/attributes/hx-swap/">hx-swap</a> attributes on this button communicate with the htmx library:</p><p>“When clicked, issue an AJAX request to /clicked and replace the entire button with the HTML response”</p><p>The same code in vanilla HTML and Javascript:</p><pre>&lt;body&gt; <br>&lt;button id=&quot;clickMe&quot;&gt;Click Me&lt;/button&gt; <br>&lt;div id=&quot;responseContainer&quot;&gt;&lt;/div&gt; <br>&lt;script&gt; <br>document.getElementById(&#39;clickMe&#39;).addEventListener(&#39;click&#39;, function() { fetch(&#39;/clicked&#39;, <br>{ method: &#39;POST&#39;, headers: { &#39;Content-Type&#39;: &#39;application/json&#39; }, body: JSON.stringify({ clicked: true }) }) .then(response =&gt; response.text()) .then(data =&gt; { // Replace the button with the response document.getElementById(&#39;responseContainer&#39;).innerHTML = data; }) .catch(error =&gt; console.error(&#39;Error:&#39;, error)); }); &lt;/script&gt; &lt;/body&gt;</pre><figure><img alt="Html application code inside of an IDE" src="https://cdn-images-1.medium.com/max/1024/0*3FzDgRA3cnnmkbzS" /></figure><p>As you can see, htmx reduces the code significantly. The library emerges as a valuable asset in the web development landscape to create modern web pages and web apps with minimal Javascript code. Though it may not provide as robust a feature set as something like NextJS or Angular, htmx may very well find a solution in a simpler use case and speed up time to market with its simple implementation and learning curve. By efficiently utilizing server-side rendering, htmx enhances performance and usability without the complexity of larger frameworks. As the htmx community grows, it offers a practical solution for developers seeking to balance simplicity and functionality, ultimately shaping the future of web development.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ecd7cbf843b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is — the algorithm that powers vector search engines and how is it relevant for you?]]></title>
            <link>https://jeremy-rivera.medium.com/what-is-the-algorithm-that-powers-vector-search-engines-and-how-is-it-relevant-for-you-38f0ac93d451?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/38f0ac93d451</guid>
            <category><![CDATA[vector]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 12 Aug 2025 13:07:06 GMT</pubDate>
            <atom:updated>2025-08-12T13:07:06.469Z</atom:updated>
            <content:encoded><![CDATA[<h3>What is HNSW— the algorithm that powers vector search engines and how is it relevant for you?</h3><figure><img alt="Geometric image representative of an algorithm" src="https://cdn-images-1.medium.com/max/1024/0*Badnr_0pUlks7Nas" /></figure><p>While working on implementing a recommendation system for one of my projects, I kept hearing about the <strong>HNSW</strong> (<a href="https://www.pinecone.io/learn/series/faiss/hnsw/"><em>Hierarchical Navigable Small World</em></a>) algorithm and its role in speeding up vector searches. Curious about its efficiency, I looked into how it works and why it’s effective for large-scale data search. HNSW’s unique structure — using layers and probabilistic skip lists — makes it ideal for fast and accurate nearest neighbor searches, which is what I needed to optimize the search experience in my app.</p><p>The HNSW<strong> </strong>algorithm is a top-performing technique for vector searches. It structures data in a way that enables ultra-fast searches and high recall, making it ideal for applications requiring quick, approximate nearest-neighbor (ANN) searches. Understanding HNSW can help you appreciate the core of how vector search engines like Pinecone operate, even though Pinecone abstracts much of this complexity for developers.</p><h3>Foundations of HNSW: How it Works</h3><h4>Proximity Graphs and Layers:</h4><p>HNSW is a type of proximity graph, where nodes (data points) are connected based on proximity (such as Euclidean distance). By incorporating layers, HNSW achieves both efficient and accurate search paths. Upper layers connect nodes with long-range links, while lower layers have more densely packed nodes with short-range links.</p><pre>import faiss<br>import numpy as np<br># Set parameters for HNSW<br>d = 128 # Dimensionality of vectors<br>M = 32 # Number of neighbors to connect each vertex<br># Initialize the HNSW index<br>index = faiss.IndexHNSWFlat(d, M)<br># Check the initial state of the HNSW index<br>print(&quot;HNSW index initialized:&quot;, index.hnsw)</pre><h4>Probabilistic Skip Lists:</h4><p>Inspired by skip lists, which allow quick navigation across ordered lists, HNSW uses layers to “skip” unnecessary nodes, speeding up searches. The algorithm moves down layers during the search, narrowing down closer to the target each time.</p><pre># Generate random vectors for demonstration<br>num_vectors = 1000000<br>xb = np.random.random((num_vectors, d)).astype(&#39;float32&#39;)<br># Add vectors to the index<br>index.add(xb)<br># Check the maximum level and distribution of levels<br>max_level = index.hnsw.max_level<br>levels_distribution = np.bincount(faiss.vector_to_array(index.hnsw.levels))<br>print(&quot;Max level in HNSW index:&quot;, max_level)<br>print(&quot;Distribution of vectors across levels:&quot;, levels_distribution)</pre><h4>Navigable Small World Graphs:</h4><p>HNSW combines elements of navigable small world (NSW) graphs, creating a structure that uses short- and long-range links to achieve logarithmic search complexity. This results in quick searches with a high probability of locating nearest neighbors efficiently.</p><pre># Generate a random query vector<br>xq = np.random.random((1, d)).astype(&#39;float32&#39;)<br># Search for the 5 nearest neighbors<br>k = 5<br>D, I = index.search(xq, k)<br>print(&quot;Nearest neighbors distances:&quot;, D)<br>print(&quot;Nearest neighbors indices:&quot;, I)</pre><h3>HNSW in Vector Search Engines: Why it Matters</h3><p>With applications in vector search engines, HNSW underpins the ability to perform searches through vast datasets in milliseconds — crucial in real-time recommendation systems, personalized search, and AI-powered assistants like Pinecone’s. For instance, querying a large collection of user or product embeddings can be done in near real-time, providing relevant, fast results.</p><p>Pinecone, for example, allows developers to integrate this kind of search without having to manage the complex index structures. Still, if you’re implementing similar functionality with other libraries like Faiss, understanding HNSW’s structure helps in fine-tuning parameters like the number of neighbors and levels in your specific application, optimizing for both recall and speed.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38f0ac93d451" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inclusive development practices in Next.js projects]]></title>
            <link>https://jeremy-rivera.medium.com/inclusive-development-practices-in-next-js-projects-0b6fc88c06af?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/0b6fc88c06af</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[a11y]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 05 Aug 2025 13:01:44 GMT</pubDate>
            <atom:updated>2025-08-05T13:01:44.342Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Banner: Inclusive development practices in Next.js projects" src="https://cdn-images-1.medium.com/max/1024/1*Z8J_qx9-xfzfOQ4U0BZu4w.png" /></figure><p>In <a href="https://www.deque.com/blog/building-accessible-apps-with-next-js-and-axe-devtools/">Part 1 of this series</a>, (<em>published June 03, 2025 on the Deque blog</em>) we explored how Next.js provides React developers a strong starting point for accessibility (A11Y), with built-in features such as semantic routing, head management, and linting. Here in Part 2, we’ll go beyond the framework to real-world development practices and demonstrate how tools like axe DevTools can help you validate real-world usability.</p><p>By “inclusive development practices,” we mean modern development techniques that ensure that applications are built accessible from the start — integrated into the design and code, rather than bolted on later or left for post-production fixes.</p><p>We’ll cover practical ways to implement accessibility at the code level, including proper use of semantic HTML, alt text, ARIA roles, and keyboard support. Below are some best practices and code examples to help you develop apps that are inclusive by design.</p><h3>Create with semantic HTML</h3><p>Swapping a generic &lt;div&gt; for a more meaningful element such as &lt;header&gt;, &lt;nav&gt;, &lt;main&gt;, or &lt;section&gt; is a simple way to improve accessibility without adding complexity. These tags help screen readers and other assistive technologies understand how your page is structured, making it easier for users to navigate.</p><p>Semantic markup increases accessibility and also makes your code cleaner and easier to maintain.</p><pre>&lt;nav&gt;<br>  &lt;ul&gt;<br>    &lt;li&gt;<br>      &lt;Link href=&quot;/&quot;&gt;Home Page&lt;/Link&gt;<br>    &lt;/li&gt;<br>    &lt;li&gt;<br>      &lt;Link href=&quot;/about&quot;&gt;About Us&lt;/Link&gt;<br>    &lt;/li&gt;<br>  &lt;/ul&gt;<br>&lt;/nav&gt;</pre><p>By choosing the right element for the job, you support better experiences for everyone without having to write extra code.</p><h3>Ensure keyboard accessibility</h3><p>Make sure every interactive element in your app functions properly for keyboard users, from navigating links to activating buttons. This means managing focus properly, maintaining a logical tab order, and using event handlers that support both mouse and keyboard input.</p><p>Native HTML elements such as &lt;button&gt; already support keyboard interactions out of the box. But if you’re building a custom interactive component (such as a &lt;div&gt; acting as a button), you need to manually support keyboard events like Enter, Space, or even arrow keys for navigation.</p><p>Here’s an example of how to make a custom component keyboard-accessible:</p><pre>&#39;use client&#39;<br>import { useRef } from &#39;react&#39;;</pre><pre>export const MyComponent = () =&gt; {<br>  const divRef = useRef(null);</pre><pre>  const handleClick = () =&gt; {<br>    // Your click handler code here<br>  };</pre><pre>  const handleKeyDown = (event) =&gt; {<br>    if (event.key === &#39;Enter&#39; || event.key === &#39; &#39;) {<br>      event.preventDefault(); <br>      divRef.current.click();<br>    } else if (event.key === &#39;ArrowLeft&#39;) {<br>      // Handle left arrow navigation<br>    } else if (event.key === &#39;ArrowRight&#39;) {<br>      // Handle right arrow navigation<br>    }<br>  };</pre><pre>  return (<br>    &lt;div<br>      ref={divRef}<br>      role=&quot;button&quot;<br>      tabIndex={0}<br>      onClick={handleClick}<br>      onKeyDown={handleKeyDown}<br>    &gt;<br>      Learn More<br>    &lt;/div&gt;<br>  );<br>};</pre><p>This pattern ensures keyboard users get the same interactive experience as mouse users — especially when you’re building components from scratch.</p><h3>Leverage ARIA roles and attributes</h3><p>When semantic HTML doesn’t cover a specific use case, you can fill in the gaps with ARIA roles and attributes. Use them thoughtfully — they’re powerful tools but not substitutes for semantic markup. ARIA, when implemented poorly, can be a barrier rather than a path to accessibility.</p><pre>&lt;nav&gt;<br>  &lt;ul role=&quot;menu&quot;&gt;<br>    &lt;li role=&quot;menuitem&quot;&gt;<br>      &lt;Link href=&quot;/&quot;&gt;Home Page&lt;/Link&gt;<br>    &lt;/li&gt;<br>    &lt;li role=&quot;menuitem&quot;&gt;<br>      &lt;Link href=&quot;/about&quot;&gt;About Us&lt;/Link&gt;<br>    &lt;/li&gt;<br>  &lt;/ul&gt;<br>&lt;/nav&gt;</pre><p>By applying roles such as menu and menuitem, you give screen readers the context they need to interpret complex or custom navigation structures. Just remember: the best accessibility often starts with native HTML. Use ARIA when needed as a complement, not as a replacement.</p><h3>Add alt text for media</h3><p>You can make your content far more inclusive simply by adding descriptive text to your images and captions to your media. Every image should include an alt attribute that communicates its purpose. If the image is decorative, use alt=”” to let assistive technologies skip it.</p><pre>&lt;Image<br>  src=&quot;/wilson.jpg&quot;<br>  width={450}<br>  height={450}<br>  alt=&quot;a wilson volleyball with a red handprint with a face on it&quot;<br>/&gt;</pre><p>For videos or audio, you can include captions or subtitles to support users who are deaf or hard of hearing:</p><pre>&lt;video controls&gt;<br>  &lt;source src=&quot;/helloWorld.mp4&quot; type=&quot;video/mp4&quot; /&gt;<br>  &lt;track kind=&quot;subtitles&quot; src=&quot;/subtitles-en.vtt&quot; label=&quot;English&quot; /&gt;<br>&lt;/video&gt;</pre><p>By taking these simple steps, you’re actively making your content more accessible to everyone, regardless of how they experience the web.</p><h3>Integrate localization</h3><p>If your audience spans multiple languages or regions, Next.js makes localization easier with built-in support for automatic locale-based routing and language negotiation.</p><p>By integrating a localization library such as next-i18next or react-intl, you can deliver content that respects your users’ language preferences and make your app feel more human in the process.</p><h3>Focus on performance and accessibility together</h3><p>Performance and accessibility go hand in hand, and with features such as server-side rendering (SSR), automatic code splitting, and route-based prefetching, you can use Next.js to ensure your app loads faster and responds smoothly.</p><p>By optimizing performance, you’re creating an app that is easier to navigate for users of assistive technology and those with slower network connections. Building with both speed and inclusivity in mind helps create a better experience for everyone.</p><h3>Test with accessibility tools</h3><p>You can catch many common accessibility issues early by using automated testing tools. Libraries such as React Testing Library with Jest make it easy to validate accessible patterns in your components:</p><pre>import { render, screen } from &#39;@testing-library/react&#39;;<br>import MyComponent from &#39;./MyComponent&#39;;</pre><pre>test(&#39;needs to be accessible&#39;, () =&gt; {<br>  render(&lt;MyComponent /&gt;);<br>  expect(screen.getByRole(&#39;button&#39;)).toBeVisible();<br>});</pre><p>Building accessibility into your test suite means it’s part of your everyday workflow, making it easier to catch issues early and deliver more inclusive features with confidence.</p><h3>Write tests with axe DevTools for browser JavaScript</h3><p>If you’re using <a href="https://www.deque.com/axe/devtools/web-accessibility/">axe DevTools for Web</a>, you can go even further by programmatically testing for accessibility violations within your browser-based JavaScript tests.</p><p>Once you’ve installed and initialized the axe DevTools browser package, you can scan any rendered component for accessibility issues. Here’s a basic example:</p><pre>test(&#39;Component has no accessibility violations&#39;, (done) =&gt; {<br>  const { container } = render(&lt;Badcomp /&gt;);<br>  axeDevTools.run(container, (err, results) =&gt; {<br>    expect(results.violations.length).toBe(0);<br>    done();<br>  });<br>});</pre><p>This test uses the run() method from @axe-devtools/browser to scan the rendered DOM and verify that there are no violations. It’s a fast, reliable way to enforce accessibility standards across your component library or app.</p><p>Need a full example? Here’s a full test file to get started:</p><pre>import React from &#39;react&#39;;<br>import Badcomp from &#39;../components/badcomp&#39;;<br>import { render } from &#39;@testing-library/react&#39;;<br>import axeDevTools from &#39;@axe-devtools/browser&#39;;<br>import &quot;babel-polyfill&quot;;</pre><pre>describe(&#39;Bad Component&#39;, () =&gt; {<br>  beforeEach((done) =&gt; {<br>    axeDevTools.init(&#39;wcag2&#39;, () =&gt; done());<br>  });</pre><pre>  test(&#39;Component has no accessibility violations, w/ attest reporter&#39;, (done) =&gt; {<br>    const { container } = render(&lt;Badcomp /&gt;);<br>    axeDevTools.run(container, (err, results) =&gt; {<br>      expect(results.violations.length).toBe(0);<br>      done();<br>    });<br>  });<br>});</pre><p>Once you’ve got the basics in place, you can expand your tests with custom rules, integrate reporting, or work directly with the results object for deeper insights.</p><h3>Use the axe DevTools Extension</h3><p>Even with Next.js, some accessibility issues will slip through, especially the trickier, context-specific ones that frameworks can miss. That’s where the <a href="https://www.deque.com/get-started-axe-devtools-browser-extension/">axe DevTools Extension</a> can help.</p><p>By adding it to your browser, you can scan your pages, spot issues visually, and zero in on exactly what needs fixing — all powered by <a href="https://github.com/dequelabs/axe-core">axe-core</a>, the engine trusted by industry leaders.</p><p>You can catch most common accessibility issues right out of the box. And when you’re ready, you can upgrade to axe DevTools Pro and get AI-powered features including Intelligent Guided Tests, which further boost your coverage. You’ll also benefit from features such as component-level testing, exportable reports, Jira integration, and more.</p><h3>Make digital accessibility part of your workflow from day one</h3><p>When you design with accessibility in mind from the outset, you make your product usable for everyone, including people with disabilities. You also avoid the cost and complexity of retrofitting later, when fixes are harder and less effective.</p><p>This early, proactive approach is part of a broader development strategy known as <a href="https://www.deque.com/shift-left-testing-solutions/">shifting left</a>, which means moving digital accessibility testing earlier in your workflow, right alongside your other quality checks. In our next article, we’ll delve into what shifting left means for digital accessibility and how it can transform your development process.</p><p>This is why Next.js offers such a solid start for React developers to build upon. It encourages developers to add accessibility to their repertoire. Whether it’s linting semantic HTML, announcing route changes, or managing metadata properly, the framework gives you guardrails to build more inclusively from the start.</p><p>Yet frameworks don’t build apps — developers do. As a developer, you have the ability and the opportunity to shape the experiences of your end-users. Next.js provides a solid foundation, and tools like the axe DevTools Extension enable you to build on that foundation, ensuring that you’re getting accessibility right, while backed by decades of proven best practices.</p><p>At Deque, our mission is to help create a digital world that works for everyone. If you’ve made it this far, you’re already part of that mission. So keep building, keep testing, and keep pushing to make the web more inclusive for all.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b6fc88c06af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What is API versioning and why is it needed?]]></title>
            <link>https://jeremy-rivera.medium.com/what-is-api-versioning-and-why-is-it-needed-f511f2f9d0a3?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/f511f2f9d0a3</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[api]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 29 Jul 2025 13:01:57 GMT</pubDate>
            <atom:updated>2025-07-29T13:01:57.394Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Github’s mascot, Github being an important tool in versioning" src="https://cdn-images-1.medium.com/max/1024/0*E6hULeLXnN01uvsi" /></figure><p>API versioning is the practice of creating multiple variants of an Application Programming Interface (API) to support varying clients and use cases. As microservice architectures become the norm, API versioning is critical due to the myriad of services that need stable communication between them. A proper versioning strategy mitigates potential downtime that could occur if that communication channel has a change invoked.</p><p>Versioning is the strategy that enables API providers to introduce new features, improve performance, or squash bugs without disrupting the applications or the users that rely on previous versions of an API.</p><h3>Why is API Versioning Needed?</h3><ol><li><strong>Backward Compatibility</strong>: When API changes are introduced, existing clients (applications that rely on an API) may not be immediately compatible with the updates. Versioning ensures that older clients can continue to function with older versions, while newer clients can use updated features.(You may choose to rollout your updates with Blue/Green deployments, canary releases, or A/B groups, etc.)</li><li><strong>Evolving Functionality</strong>: APIs often need to iterate as business requirements change or new technology becomes needed. API versioning allows engineers to add, modify, or deprecate functionality gradually without breaking client applications.</li><li><strong>Error Reduction in Client Applications</strong>: Without a proper versioning strategy, updates to an API could cause errors in applications relying on earlier API structures or data. Versioning minimizes unexpected downtime, allowing clients to adapt at their own pace.</li><li><strong>Maintaining Documentation Clarity</strong>: Different API versions enable clear documentation of functionality available at specific stages.</li><li><strong>Support for Long-Term Applications</strong>: Some applications, especially in enterprise environments, rely on stability over time. By maintaining multiple versions, an API provider supports both legacy applications and newer clients.</li></ol><h3>Common API Versioning Strategies</h3><ul><li><strong>URL Versioning</strong>: Including the version number in the URL (e.g., /api/v1/resource).</li><li><strong>Query Parameters</strong>: Adding the version as a query parameter (e.g., /api/resource?version=1).</li><li><strong>Header Versioning</strong>: Specifying the version in the request header (e.g., API-Version: 1).</li><li><strong>Content Negotiation</strong>: Using different media types to request different versions, though less common.</li></ul><p>API versioning is essential to foster a smooth developer experience and a stable, evolving product without disrupting existing integrations​</p><figure><img alt="Laptop with a blue screen and a loading circle centered" src="https://cdn-images-1.medium.com/max/1024/0*Ge8QGUEbkasO2R6z" /></figure><p><strong>KushoAI and API management</strong></p><p>KushoAI is an AI-powered tool designed for automated API testing, streamlining the testing process by generating test suites for APIs in just minutes. It allows developers to upload an API spec (<em>e.g., OpenAPI, Postman Collection, cURL</em>) or manually enter API details, after which KushoAI analyzes various API parameters, including data types and values, and creates real-world test scenarios. This testing approach helps developers catch issues before deployment, offering peace of mind and reducing the chance of production downtime.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><p>In the context of API versioning, KushoAI can be particularly valuable by ensuring compatibility across versions. By automatically testing multiple API versions and their endpoints, KushoAI can identify breaking changes early and help maintain consistent functionality across different versions, enabling smooth version transitions for both users and developers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f511f2f9d0a3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What are some practical use cases for the pinecone assistant?]]></title>
            <link>https://jeremy-rivera.medium.com/what-are-some-practical-use-cases-for-the-pinecone-assistant-88a56e18f11f?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/88a56e18f11f</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 22 Jul 2025 13:33:01 GMT</pubDate>
            <atom:updated>2025-07-22T13:33:01.145Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Pinecone resting on a table" src="https://cdn-images-1.medium.com/max/1024/0*DFAbTPWRSL7xzk8p" /></figure><h4>Understanding Pinecone Assistant</h4><p>Pinecone Assistant is a <strong>RAG</strong> <strong>(</strong><a href="https://www.pinecone.io/learn/retrieval-augmented-generation/"><strong><em>retrieval-augmented generation</em></strong></a><strong>) service</strong> designed to provide accurate, data-based answers by referencing uploaded documents. Users can interact with it via the Pinecone console, a Python plugin, or the Assistant API, making it a versatile tool for developers. Currently, Pinecone Assistant is in <a href="https://docs.pinecone.io/guides/assistant/understanding-assistant">public preview</a>, with planned improvements to expand features and supported file types.</p><p>When you upload a document, this Assistant processes it by <strong>chunking and embedding the text</strong> into a vector database. It then uses this context to produce answers by querying a large language model (LLM) that is “grounded” in your documents. In this setup, Pinecone manages all of the underlying complexities, such as storage, querying, and embedding generation, leaving the developer free to focus on asking questions.</p><h4>Practical Use Cases for Pinecone Assistant</h4><p><strong>Financial Analysis and Reporting <br></strong>Financial teams and analysts often need to analyze complex data quickly, such as quarterly earnings reports or regulatory filings. With Pinecone Assistant, they can upload large PDF reports, like 10-K or 10-Q filings, and retrieve insights without manually combing through documents. For instance, they could ask, “What share repurchases has NVIDIA made recently?” or “What was the revenue growth last quarter?” and receive context-rich answers instantly.</p><p><strong>Legal Document Review and Compliance<br></strong>Law firms and compliance teams regularly work with lengthy legal documents and need quick access to specific clauses or terms. Pinecone Assistant allows them to upload contracts, policy documents, and case files to quickly answer questions like, “What are the main compliance requirements in our latest contract?” or “What are the key terms in the privacy policy?” This capability can streamline legal research and ensure accurate document reviews.</p><p><strong>Customer Support Knowledge Bases<br></strong>In customer support, having immediate access to technical information or product details is essential. Pinecone Assistant can serve as a knowledge base, allowing support teams to quickly answer questions from internal documents or user manuals. For example, support agents could upload a troubleshooting guide and instantly retrieve solutions by asking questions such as, “How do I reset my device?” or “What are the warranty terms for this product?”</p><p><strong>Healthcare Documentation and Research<br></strong>Healthcare professionals and researchers often rely on technical reports and medical literature to make informed decisions. With Pinecone Assistant, they can upload research papers, patient guidelines, or clinical data and ask precise questions to get grounded, secure answers. This application is ideal for hospital administrators, research labs, or regulatory teams who must ensure data privacy while accessing accurate insights from complex data.</p><p><strong>Training and Onboarding in Enterprise Environments<br></strong>Organizations can also use Pinecone Assistant to create a repository of internal training materials, operational guidelines, and onboarding documents. This setup can streamline the onboarding process by enabling new employees to ask questions directly, such as “What are the company’s data privacy protocols?” or “How do I set up my workstation according to security guidelines?” Using Pinecone Assistant in this way can help improve knowledge retention and reduce the time new employees spend looking for answers.</p><h4>Key Limitations and Access Levels</h4><p>Though Pinecone Assistant offers a powerful way to interact with proprietary data, it comes with certain limitations based on the user’s access plan:</p><ul><li><strong>Starter Plan</strong>: Allows up to 3 assistants per organization, a 1GB storage limit per assistant, and 10 total uploads per assistant.</li><li><strong>Standard and Enterprise Plans</strong>: These plans expand limits considerably, allowing unlimited assistants per organization, 10GB of storage per assistant, and up to 10,000 files per assistant.</li></ul><p>Supported file types are currently limited to <strong>.txt and .pdf</strong>, and Pinecone Assistant only supports the <strong>Python SDK</strong> (JavaScript and Java SDKs are not yet compatible).</p><p><em>PythonSDK Example:</em></p><pre>pip install - upgrade pinecone pinecone-plugin-assistant</pre><h3>Conclusion</h3><p>With Pinecone Assistant, organizations can transform complex, data-rich documents into interactive and secure knowledge bases that provide immediate answers. From simplifying legal document review to enhancing customer support and training, Pinecone Assistant offers practical, time-saving applications across various sectors. As the tool moves beyond public preview, we can expect even more robust capabilities and broader SDK support, making it a powerful AI asset for any team looking to enhance their data retrieval systems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88a56e18f11f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What are service quotas on AWS? How can they become a barrier in scaling your application?]]></title>
            <link>https://jeremy-rivera.medium.com/what-are-service-quotas-on-aws-how-can-they-become-a-barrier-in-scaling-your-application-4cd9d4b2e37c?source=rss-68b60f6c2c38------2</link>
            <guid isPermaLink="false">https://medium.com/p/4cd9d4b2e37c</guid>
            <category><![CDATA[metrics]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Jeremy Rivera]]></dc:creator>
            <pubDate>Tue, 15 Jul 2025 13:26:57 GMT</pubDate>
            <atom:updated>2025-07-15T13:26:57.053Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Several metrics on a computer screen" src="https://cdn-images-1.medium.com/max/1024/0*h-I5TkeDdqm-0wqc" /></figure><p>We live in a time where anyone can learn a few DevOps skills that enable them to provision infrastructure within minutes and scale applications with ease. Dynamic scaling is a pinnacle of cloud-native architecture and is critical to keeping applications highly available and reducing undesired latency.</p><p>With great power though, comes an even greater responsibility. AWS stands as a pillar in the cloud computing ecosystem, holding almost a third of the <a href="https://www.statista.com/chart/18819/worldwide-market-share-of-leading-cloud-infrastructure-service-providers/">market share</a> for service providers. AWS enables any organization to adequately provision and scale their applications with relative ease on their platform.</p><p>Yet, despite its extensive capabilities, AWS’s ability to scale your application’s infrastructure is not without limits. Understanding these limitations is critical for engineers and organizations seeking to harness the full potential of the cloud while avoiding pitfalls.</p><p>The limits AWS imposes are under what they call <em>service quotas</em> and are <a href="https://aws.amazon.com/about-aws/whats-new/2019/06/introducing-service-quotas-view-and-manage-quotas-for-aws-services-from-one-location/">defined by the provider</a> as follows:<br><em>“Quotas, also referred to as limits, are the maximum number of resources that you can create in an AWS account. AWS implements quotas to provide highly available and reliable service to all customers, and protect you from unintentional spend.”</em></p><p>In other words, AWS imposes these limits<br> a) to prevent one organization from eating into too many resources single-handedly &amp;<br>b) to protect an organization from scaling to the point where it leads to over consumption of resources and a very large bill.</p><p>[<em>For those interested, </em><a href="https://www.cnbc.com/2019/04/22/apple-spends-more-than-30-million-on-amazon-web-services-a-month.html#:~:text=Apple%20spends%20more%20than%20$30%20million%20a%20month%20on%20Amazon%20Web%20Services"><em>see Apple’s monthly AWS bill</em></a>]</p><p><strong>How Service Quotas Can Become A Barrier to Scaling Applications</strong></p><p>As applications grow and demand increases, service quotas can present significant challenges that hinder scaling efforts. Here are some of the key areas where these quotas can impact application performance and availability:</p><p>1. <strong>Resource Limits</strong>: Each AWS service has predefined limits on the resources it can provision. For instance, there are limits on the number of EC2 instances you can run in a region or the throughput of an S3 bucket. When these limits are reached, applications may experience failures or performance degradation, which can affect user experience.</p><p>2. <strong>IAM Roles and Policies</strong>: AWS Identity and Access Management (IAM) has its own limits, such as the number of IAM roles and policies you can create. If your application architecture requires more roles than permitted, it can impede the deployment of new services or applications that need specific permissions, thereby stalling development and growth.</p><p>3. <strong>Network Quotas</strong>: Quotas on networking components, such as Virtual Private Clouds (VPCs), subnets, and IP addresses, can restrict your ability to expand your network architecture. As your application scales, the inability to create new network resources can lead to bottlenecks and limit your overall capacity.</p><p>4.<strong> Service-Specific Quotas</strong>: Each AWS service has its unique quotas, which can vary widely. For example, API Gateway has limits on the number of requests per second. If an application experiences a sudden spike in traffic, it may be throttled, resulting in slow responses or downtime.</p><p>5.<strong> Scaling Challenges</strong>: Auto-scaling groups are designed to automatically adjust the number of instances in response to demand. However, if you reach a quota limit, new instances may not be launched, even in the face of high demand. This can lead to service outages or degraded performance during peak usage times.</p><p>6. <strong>Cost Implications</strong>: Scaling often involves requesting increases in service quotas. This process can take time, and delays in approval can hinder your ability to respond to increased demand. Additionally, scaling to higher service tiers may incur additional costs, impacting your budget.</p><figure><img alt="People planning on a whiteboard" src="https://cdn-images-1.medium.com/max/1024/0*aGrmGR8EfRrbAMGu" /></figure><p><strong>Mitigating Service Quota Issues</strong></p><p>To effectively manage and mitigate the challenges posed by service quotas, consider the following strategies:</p><p>1. <strong>Monitoring</strong>: Regularly monitor your service quotas using tools like AWS CloudWatch or the AWS Management Console. Keeping an eye on your limits allows you to anticipate potential issues before they impact your application.</p><p>2. <strong>Quota Increase Requests</strong>: AWS allows you to request increases in service quotas. It’s prudent to plan ahead and submit these requests before you hit your limits, especially during expected growth phases. This proactive approach can help ensure that you have the necessary resources when you need them.</p><p>3. <strong>Design for Limits</strong>: Architect your application with service limits in mind. Implement strategies like circuit breakers or fallback mechanisms to ensure that your application can gracefully handle situations where quotas are reached, minimizing the impact on users.</p><p>4. <strong>Use AWS Trusted Advisor</strong>: AWS Trusted Advisor is a valuable tool that can help identify areas where you are approaching service limits. It provides recommendations on best practices and actions to mitigate potential issues, allowing you to stay ahead of quota-related challenges.</p><p>Understanding the implication of service quotas and then implement strategies to monitor and manage them. Some of the above tools can provide assistance when determining the best path forward for your organization’s applications. Requesting an increase for quotas are a solution but it would also be wise to see what is causing the application to quickly demand more resources. Perhaps there is unnecessary bloat or a way to optimize instance usage. Only with a dutiful eye and a respect for the infrastructure and prover can an organization truly take advantage of all that a cloud provider, such as AWS, can offer.</p><p>Though service quotas exist, they do in a large part to protect AWS’s customers from unwanted fees and over-provisioning. As your organization continues to look forward and scale, view quotas as a friend, not a foe, and also try to manage the application’s infrastructure to see if there are any pieces that need a refactor or further thought to truly determine if a request is 100% necessary.</p><p><em>This blog was written for KushoAi Q4, 2024 as a Developer Relations Specialist: </em><a href="https://blog.kusho.ai/"><strong><em>https://blog.kusho.ai/</em></strong></a><strong><em> </em></strong><em>I wanted to also publish it here as a record for my portfolio.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4cd9d4b2e37c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>