<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Emmanuel Paul</title>
    <description>The latest articles on DEV Community by Emmanuel Paul (@paul_emmanuel).</description>
    <link>https://dev.to/paul_emmanuel</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F2805211%2F44d39c43-5fc3-4e5c-8aee-6b3032f80e50.png</url>
      <title>DEV Community: Emmanuel Paul</title>
      <link>https://dev.to/paul_emmanuel</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/paul_emmanuel"/>
    <language>en</language>
    <item>
      <title>System Design for Beginners: Where Do You Start?</title>
      <dc:creator>Emmanuel Paul</dc:creator>
      <pubDate>Fri, 06 Nov 2026 18:18:51 +0000</pubDate>
      <link>https://dev.to/paul_emmanuel/system-design-for-beginners-where-do-you-start-c4a</link>
      <guid>https://dev.to/paul_emmanuel/system-design-for-beginners-where-do-you-start-c4a</guid>
      <description>&lt;p&gt;Hey again, Emmanuel here. Another week of surviving the unstable field of software development. According to advice I see online from many senior devs, one of the best skills you can build right now is understanding system design. Learning how the components of an app fit together, analyzing trade-offs, and justifying architectural decisions are skills I didn’t possess. However, like with any skill, learning and practice are all you need to get “good.”&lt;/p&gt;

&lt;p&gt;That’s why I started learning the basics of system design. I’m not talking about designing software at the level of platforms like Netflix or Spotify. No, I’m starting with something far more manageable for beginners like me: a URL Shortener. So, what exactly is system design?&lt;/p&gt;

&lt;h2&gt;
  
  
  So, What Exactly Is System Design?
&lt;/h2&gt;

&lt;p&gt;System design is the process of planning the architecture of a software system. It’s essentially a kind of blueprint that defines the various components of a system, their relationships, and how data flows between them. To keep it fairly brief, I’ll use an analogy of a building. In this scenario, coding is like laying individual bricks or placing the wiring. System design, however, is like planning how many floors the building has, where the plumbing goes, and how it can support people without collapsing.&lt;/p&gt;

&lt;p&gt;When I say “components,” I mean servers, databases, and stuff like that. Before you even start designing anything, you need to understand the requirements of the system. These usually fall into two categories: functional and non-functional requirements. Functional requirements are the essentials of the system, as they describe what it must do to function. On the other hand, the non-functional requirements are how well the system performs. For non-functional requirements, we consider factors like speed, availability, reliability, and security.&lt;/p&gt;

&lt;p&gt;System design is typically split into two main layers: High-Level Design (HLD) and Low-Level Design (LLD). As the name hints, the HLD focuses on the high-level architecture. It maps out the connections of components like web servers, CDNs, databases, and client-facing applications. On the other hand, the LLD focuses on the smaller details. Stuff like the logic of individual modules, classes, and data structures within particular services. So, you usually start with the HLD, then move on to the LLD when designing a system.&lt;/p&gt;

&lt;p&gt;Now, I initially thought system design was something I had to worry about when creating large production-grade systems. That’s not the case, though, as even small apps require architectural decisions (though we often overlook them). And what better way to understand this than trying to design a system ourselves?&lt;/p&gt;

&lt;h2&gt;
  
  
  Our First Problem: A URL Shortener
&lt;/h2&gt;

&lt;p&gt;As I mentioned in the intro, I plan to design a URL shortener. Why? Because it’s a fairly common example with a straightforward design, and it also stops me from going overboard. If you don’t know what a URL shortener is, it’s simply a system that takes a long URL and produces a shorter link that redirects visitors to the original destination. For instance, I might submit a link like “example.com/articles/learning-system-design” and receive a shortened link like “short.ly/aB92x.”&lt;/p&gt;

&lt;p&gt;Firstly, we need to understand the core functional requirements of our URL shortener. It needs to:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Accept a URL&lt;/li&gt;
&lt;li&gt;Generate a unique short code&lt;/li&gt;
&lt;li&gt;Map the short link to the original long URL in the database&lt;/li&gt;
&lt;li&gt;Redirect visitors when they access the shortened link&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If we’re talking about the functional requirements, then these are enough for our basic URL shortener. You see that it clearly describes what the system must do. For non-functional requirements, we might consider the speed of redirects, handling database failures, and making the application handle increasing traffic.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Note that I won’t be considering extra stuff like user accounts, analytics, or link expiration to keep this design simple. Don’t judge me :(&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Now that we have a good idea of the requirements of our URL shortener, we can finally move on to actually designing the system.&lt;/p&gt;

&lt;h2&gt;
  
  
  How Would We Design It?
&lt;/h2&gt;

&lt;p&gt;Our system requirements are now well-defined, so we can actually start the design process. We need to identify the major components, which act as the building blocks of our entire system. For such a simple URL shortener, I decided to split it into three components:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Client:&lt;/strong&gt; A client-facing component where you can submit URLs and access shortened links&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Backend/Server:&lt;/strong&gt; Handles requests, generates short codes, and redirects&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Database:&lt;/strong&gt; Stores the mapping of the short codes and original long URLs&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fss7fuzlf0cn4fryjfw6s.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fss7fuzlf0cn4fryjfw6s.png" alt=" " width="800" height="400"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;With the HLD components mapped out, we need to understand the URL creation flow. I’ve summed it up in a few steps:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A user submits a URL in the client interface&lt;/li&gt;
&lt;li&gt;The long URL is sent to the backend through an HTTP request&lt;/li&gt;
&lt;li&gt;Next, the backend checks the submitted value to ensure it's a valid URL&lt;/li&gt;
&lt;li&gt;The backend server generates a short code to represent the original URL (e.g., "aB92x")&lt;/li&gt;
&lt;li&gt;The short code and original URL are stored in the database&lt;/li&gt;
&lt;li&gt;Finally, the backend returns the shortened URL (e.g., "short.ly/aB92x")&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Breaking the URL creation process down like this makes it quite easy to understand and implement. Besides that, the redirection process is the next major part of our URL shortener:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The visitor opens the shortened URL (let’s say “short.ly/aB92x”)&lt;/li&gt;
&lt;li&gt;The backend extracts the code “aB92x” from the request&lt;/li&gt;
&lt;li&gt;The database is queried for the associated long URL&lt;/li&gt;
&lt;li&gt;If a matching record is found, the original URL is retrieved&lt;/li&gt;
&lt;li&gt;If a record isn’t available, an HTTP 404 Not Found response is sent&lt;/li&gt;
&lt;li&gt;The visitor is finally redirected to the original URL, with a 302 status code&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;And just like that, you get a decent overview of the whole system without needing to write even a single line of code. Now, having this design gives you a clearer starting point when implementation begins.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Could Go Wrong?
&lt;/h2&gt;

&lt;p&gt;One thing to keep in mind about the design of our URL shortener is that it’s frankly as simple as it gets. However, system design isn’t just about finding a solution that works. It also requires you to understand where things break and how to fix them as requirements evolve. If our URL shortener suddenly has to serve millions of users, several things could go wrong.&lt;/p&gt;

&lt;p&gt;Let’s say you process two different original URLs, and somehow, our underlying code generates the same short code for both. Obviously, that is a major problem, as it gets two different links to redirect visitors to. To fix this, we would need to handle uniqueness in our short code generation. We need sufficient collision handling to check for duplicated codes and regenerate until a unique one is obtained. You can also add a UNIQUE constraint to the database itself to avoid storing duplicate values under the short code column/attribute.&lt;/p&gt;

&lt;p&gt;Here’s another problem to consider. We get thousands of visitors accessing our shortened links, which leads to many requests to our backend server and database. Due to all this high traffic, our system starts struggling to process requests. For this, we may decide to scale out our system by adding more server instances to handle requests. Scaling out might mean adding a load balancer to distribute requests among our multiple servers. To avoid hitting our database on every request, we can add a cache to our system to store frequently accessed URL mappings. Only when the cache doesn’t contain the requested mapping do we query our database.&lt;/p&gt;

&lt;p&gt;Lastly, we need to consider database failures. What happens when our database fails and can’t return our mappings? That’s why you need to have database backups to help restore data after data loss, corruption, or certain failures. We can also create database replicas to maintain copies of data, and they can potentially take over when the primary database becomes unavailable.&lt;/p&gt;

&lt;p&gt;One thing I can’t stress enough is that these changes are for when your URL shortener needs to handle more users. Don’t try to add all these for a shortener that only serves a few people. It’s best to identify performance issues as they occur and fix them accordingly.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I've Learned So Far
&lt;/h2&gt;

&lt;p&gt;So, what did I learn after all of this? Well, firstly, system design isn’t as clear-cut as I initially thought. It’s less about finding the perfect approach and more about understanding trade-offs and requirements. You get to consider where things break and improvements that can be made while still avoiding unnecessary complexity.&lt;/p&gt;

&lt;p&gt;Personally, it also helps in keeping my plans grounded. I usually start coding without much thought and then run into different unplanned features. Eventually, I abandon the project because I get overwhelmed by the numerous features I could build. Now, I try my best to design the system before anything else.&lt;/p&gt;

&lt;p&gt;Should you learn system design? Yes, I wholeheartedly recommend doing that. Even if AI makes building things quite easy, understanding how things work together, making decisions, and recognizing trade-offs are still important.&lt;/p&gt;

</description>
      <category>systemdesign</category>
      <category>tutorial</category>
      <category>webdev</category>
      <category>programming</category>
    </item>
    <item>
      <title>Your App Works Locally. What Changes When It Goes to Production?</title>
      <dc:creator>Emmanuel Paul</dc:creator>
      <pubDate>Fri, 30 Oct 2026 16:09:54 +0000</pubDate>
      <link>https://dev.to/paul_emmanuel/your-app-works-locally-what-changes-when-it-goes-to-production-g87</link>
      <guid>https://dev.to/paul_emmanuel/your-app-works-locally-what-changes-when-it-goes-to-production-g87</guid>
      <description>&lt;p&gt;Hey, Emmanuel here. While I was pondering what to write about this week, I ran into an old project of mine: Relay (A “real-time” messaging platform). Think Facebook, but without any of the stuff that makes it good, like real people and the ability to actually send friend requests. Truth be told, it’s just a badly designed message board with a fixed amount of people :( that I built to learn about Websockets.&lt;/p&gt;

&lt;p&gt;The main thing is that I remembered the absolute nightmare it was to deploy it. It’s not that I haven’t deployed a full-stack application before. No, it’s because the “genius” that made the tutorial decided to build the frontend and backend separately and then eventually move it to the same codebase for a single deployment. He configured a single build command for both ends and a lot of shoddy fixes to get it to work.&lt;/p&gt;

&lt;p&gt;Thanks to the experience (PTSD) I got from that project, future deployments became substantially easier. So, that gave me the idea to write about taking your app to production. After building it on your machine, what comes next?&lt;/p&gt;

&lt;h2&gt;
  
  
  It Works on My Machine. What's the Problem?
&lt;/h2&gt;

&lt;p&gt;Having an app that works on your machine but breaks when it hits production is one of the major rites of passage for developers. When you run your app from your machine, it basically acts as a personal server to handle requests and responses. But that works for just your machine, as someone else making a request to &lt;em&gt;&lt;a href="http://localhost:5000" rel="noopener noreferrer"&gt;http://localhost:5000&lt;/a&gt;&lt;/em&gt; sends it to their own device, not yours.&lt;/p&gt;

&lt;p&gt;So, deployment means getting your app out of your device and making it accessible to others. However, a lot, and I mean, a lot of things can easily make things spiral out of control. &lt;/p&gt;

&lt;p&gt;While developing locally, you often know exactly where everything is, how it connects, and which configuration values it needs. Deployment forces those assumptions to become explicit. Where does the frontend run? Where does the backend run? How do they communicate? Where is the database hosted? How does the application know which URLs and credentials to use? Those are all questions you need to consider when getting your app out of development and into production.&lt;/p&gt;

&lt;h2&gt;
  
  
  Your App Needs a Home
&lt;/h2&gt;

&lt;p&gt;Firstly, your app needs a home, which is a server that it runs on. Running it locally doesn’t allow external users on other devices to be able to send requests to your server (I know certain network configurations can let it do that, but by default, it doesn't). Therefore, you need a hosting provider, which is a platform that basically offers you a chunk of their infrastructure to run your application. The exact cloud hosting provider you choose depends on your use case, requirements, and budget. For Relay, however, I used Render (this is my go-to, as their free tier is quite generous).&lt;/p&gt;

&lt;p&gt;As you probably know, not every part of your application lives in one place. Usually, you have the frontend of the app, which deals with the client-facing services like the UI, while the backend manages data, logic, and security. Now, the way you deploy your application depends on how you arrange the frontend and backend.&lt;/p&gt;

&lt;p&gt;For combined deployment, the frontend is built into static files, and a server serves those files while receiving backend requests. This is actually how I first started web development, using EJS (Embedded JavaScript) alongside Express/Node.js to serve my frontend. With this arrangement, you deploy the whole thing as one, as the backend receives requests directly and serves the appropriate frontend file.&lt;/p&gt;

&lt;p&gt;However, I eventually discovered that separate deployment was the popular choice. The frontend and backend are deployed as separate services, usually with different URLs. For Relay, I actually used this arrangement. The React frontend displayed the UI, and the backend provided the core logic, like authentication, messaging, and account creation.&lt;/p&gt;

&lt;p&gt;So now, your frontend and backend are now deployed. However, if you used the separate deployment approach, they still need to be able to communicate with one another. So, how do we do that?&lt;/p&gt;

&lt;h2&gt;
  
  
  The Frontend and Backend Need to Find Each Other
&lt;/h2&gt;

&lt;p&gt;It’s quite obvious that both ends of your application need to communicate to actually work. For that, we use an API (a set of rules and protocols that allows different software applications to communicate and share data with each other). During development, the backend API runs on localhost (something like &lt;em&gt;&lt;a href="http://localhost:5000/api/" rel="noopener noreferrer"&gt;http://localhost:5000/api/&lt;/a&gt;&lt;/em&gt;). Hence, the frontend sends requests to that url.&lt;/p&gt;

&lt;p&gt;However, when deployed, both ends get live URLs. Back then, I didn’t know most of this, so I wondered why Relay didn’t work when deployed. After a few frustrating minutes, I discovered I was still sending requests to &lt;em&gt;&lt;a href="http://localhost:5000/api/" rel="noopener noreferrer"&gt;http://localhost:5000/api/&lt;/a&gt;&lt;/em&gt; from the deployed frontend. I recommend using environment variables rather than hardcoding these paths, as it’ll be easier to switch between development and production URLs without changing your code.&lt;/p&gt;

&lt;p&gt;Of course, there are many other things that can go wrong. In my own case, I also experienced a CORS (Cross-Origin Resource Sharing) error. Keep in mind that this is a security feature designed to stop malicious sites from secretly reading your data on other websites. Notably, tools like Postman or curl don’t enforce CORS, so your API might work during development but fail when it hits production.&lt;/p&gt;

&lt;p&gt;Fortunately, CORS errors are straightforward to handle. All you need to do is configure your backend server to include specific HTTP response headers. Setting these headers lets you provide the live frontend URL, list the allowed methods, and even include custom headers. If, like me, you use Express/Node.js for the backend, you can do this by installing the cors package and setting it up.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where Does Your Data Live?
&lt;/h2&gt;

&lt;p&gt;More often than not, your application might need to access a database for full functionality. However, a database running locally on your development machine isn’t automatically accessible by your deployed application. For this, you use a cloud database service; Supabase, Neon, and AWS RDS can provide PostgreSQL databases, while MongoDB Atlas hosts MongoDB databases.&lt;/p&gt;

&lt;p&gt;After setting up a database from any of these cloud providers, you get a connection string. You can then configure your backend to use this connection string for accessing the database. However, DON’T hardcode the connection details in your code; use environment variables to securely pass in the required database access credentials.&lt;/p&gt;

&lt;p&gt;I actually used MongoDB Atlas (the tutorial made me do that :( ) while building Relay, so the connection URI was set right from the development stage.&lt;/p&gt;

&lt;h2&gt;
  
  
  From Localhost to a Live Application
&lt;/h2&gt;

&lt;p&gt;I’ve always heard about deployment issues from other devs, but getting a firsthand experience is something else. Turns out getting an application working locally is a far different game from making it accessible, secure, and reliable once it’s live. However, as I’ve now learned, each frustrating deployment teaches a valuable lesson.&lt;/p&gt;

&lt;p&gt;Looking back, Relay wasn't exactly my finest work, but the deployment experience taught me things I wouldn't have learned by simply following a tutorial. Take your time, understand how the different pieces fit together, and don't be afraid to troubleshoot.&lt;/p&gt;

</description>
      <category>programming</category>
      <category>webdev</category>
      <category>tutorial</category>
      <category>beginners</category>
    </item>
    <item>
      <title>I'm Learning to Code in the Age of AI. Is That a Problem?</title>
      <dc:creator>Emmanuel Paul</dc:creator>
      <pubDate>Fri, 23 Oct 2026 18:40:56 +0000</pubDate>
      <link>https://dev.to/paul_emmanuel/im-learning-to-code-in-the-age-of-ai-is-that-a-problem-4cmf</link>
      <guid>https://dev.to/paul_emmanuel/im-learning-to-code-in-the-age-of-ai-is-that-a-problem-4cmf</guid>
      <description>&lt;p&gt;“Adapt or die.” That phrase perfectly sums up the unstable software engineering industry in this age of AI. Whenever we set aside the fear of AI taking our jobs, we’re often met with the same reassurance: AI isn’t replacing developers; developers who know how to leverage AI will come out on top.&lt;/p&gt;

&lt;p&gt;And sure, that sounds reasonable for senior developers with years of experience and solid skills to back them up. But what about junior and entry-level developers, myself included? How do I possibly leverage AI to become a better software engineer when the foundation hasn’t been built yet?&lt;/p&gt;

&lt;h2&gt;
  
  
  Learning to Code in a Different Era
&lt;/h2&gt;

&lt;p&gt;Before I start, it’s probably best to offer some context. I’m a full-stack developer currently focused on web development, though I plan to expand my skill set down the road. I’m still an entry-level/junior dev, and my only “working experience” so far comes from a remote internship I recently completed at a somewhat shady company.&lt;/p&gt;

&lt;p&gt;Now, it should be obvious that I still have plenty of room to grow, both in terms of my technical skills and actual work experience. But that’s exactly the problem. With how volatile the industry is right now, thanks to AI and the aftermath of post-COVID overhiring (and now layoffs), being at the very bottom of the software development career ladder isn’t exactly a great position.&lt;/p&gt;

&lt;p&gt;Despite all this, I’m still learning to code manually. According to many experts, though, coding by hand is dead. What matters now is having “taste,” making high-level decisions, and understanding trade-offs while letting AI handle the “boring” part: implementation.&lt;/p&gt;

&lt;p&gt;That sounds great. Until you consider that those skills and that judgment come from years of learning and experience, often gained on the job. You can’t reliably judge an AI’s code quality or spot its flaws when you don’t yet understand what good code looks like.&lt;/p&gt;

&lt;h2&gt;
  
  
  Using an AI Assistant Changes Everything
&lt;/h2&gt;

&lt;p&gt;Whether for better or worse, it's clear that AI has changed everything. I'm not particularly against artificial intelligence (GenAI, to be specific), though I'm quite aware of its numerous downsides. &lt;/p&gt;

&lt;p&gt;When it comes to learning to code, I actively use AI as a learning tool. It helps me break down obscure concepts, provides coding challenges, and even points me toward useful resources. Whenever I get stuck on a problem or confused while debugging my code, getting help is just a click or prompt away. And that, in itself, is the problem.&lt;/p&gt;

&lt;p&gt;I've come to realize that solving problems doesn't automatically make you a better programmer. The friction involved in solving them matters just as much. Taking a problem, working through it, deeply thinking, making mistakes, and eventually finding a solution helps develop the problem-solving skills software engineers need.&lt;/p&gt;

&lt;p&gt;But with a handy assistant always within reach, I've made it incredibly easy to bypass that friction, even when it's exactly what I need. It's like being stuck in tutorial hell, except somehow worse. I get a false sense of progress that looks solid at a cursory glance but crumbles when put under real pressure.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Happens When the AI Isn't There?
&lt;/h2&gt;

&lt;p&gt;Outsourcing your intelligence to AI is one of the worst things to do. Letting tools like ChatGPT or Claude handle our thinking, problem-solving, and decision-making actively weakens our “mental muscles” due to lack of use.&lt;/p&gt;

&lt;p&gt;With AI at my side, I sometimes solve problems without giving them much thought. I accept its answers without much questions, and that makes things harder when the assistant isn't there. I start overthinking, doubting things I genuinely know, and struggling to recall even basic concepts I haven't practiced in a while.&lt;/p&gt;

&lt;p&gt;A quick search led me to the concept of &lt;em&gt;cognitive laziness&lt;/em&gt;: the tendency to avoid putting in mental effort when an easier alternative is available. Over-relying on AI can encourage this habit, particularly when we let it do the thinking instead of using it to support our own. It’s a horrible cycle. The more we depend on AI to solve problems, the less practice we get solving them independently, which can make us even more dependent on AI.&lt;/p&gt;

&lt;p&gt;In my own case, I sometimes struggle to explain code I've written with AI's help. Adapting it to changing requirements can be difficult because, while I understand the overall idea, the actual implementation feels foreign to me.&lt;/p&gt;

&lt;h2&gt;
  
  
  I Still Want to Understand the Code I Write
&lt;/h2&gt;

&lt;p&gt;Most developers who embrace the AI boom argue that it “lets them skip the boring part of typing and focus on high-level decisions.” Well, I actually love what they refer to as the boring part. Thinking through problems, typing out code to solve them, and simply enjoying the logic feels great to me.&lt;/p&gt;

&lt;p&gt;So, even if it makes me feel slower in the short term, I'll try to avoid reliance on AI tools. For now, I'll attempt to solve problems myself, thinking deeply when I'm stuck, rather than relying on some tool, and take the time to understand an implementation instead of blindly accepting it.&lt;/p&gt;

&lt;p&gt;Using AI to speed up as a shortcut feels like strapping a rocket to a horse-drawn carriage. Sure, it'll go faster, but how long before the whole thing falls apart? And if that becomes the norm, I’d have to ask whether I’m still learning software development or signing up to supervise AI.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>webdev</category>
      <category>healthydebate</category>
    </item>
    <item>
      <title>Jev Explained: What If AI Didn't Need to Chat?</title>
      <dc:creator>Emmanuel Paul</dc:creator>
      <pubDate>Fri, 16 Oct 2026 06:30:56 +0000</pubDate>
      <link>https://dev.to/paul_emmanuel/jev-explained-what-if-ai-didnt-need-to-chat-231d</link>
      <guid>https://dev.to/paul_emmanuel/jev-explained-what-if-ai-didnt-need-to-chat-231d</guid>
      <description>&lt;p&gt;Hey 👋, Emmanuel here. Unless you've been living under a rock, you’ve probably heard of Jev (a new AI decision model from TypeSafe AI). It was launched in September, and although my feeds were packed with news about it, I still had no idea what exactly it was or how it differed from standard Large Language Models (LLMs) like ChatGPT and Claude.&lt;/p&gt;

&lt;p&gt;Well, until now, that is. Yep, I’ve done some research on TypeSafe AI’s "Jev," focusing mainly on what makes it different from standard LLMs. Could this actually change how we build AI-powered applications, or is it just another model being hyped?&lt;/p&gt;

&lt;h2&gt;
  
  
  What is Jev?
&lt;/h2&gt;

&lt;p&gt;According to TypeSafe AI, Jev is a specialized non-generative AI decision model. Note that I refer to it as “non-generative,” which is due to the fact that it doesn’t write prose, chat, or generate text. Rather, Jev is a decision model that simply evaluates unstructured input data against predefined questions and returns structured probabilistic decisions. Unlike the traditional LLMs we are used to, Jev is a pure System One model.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;System One is a conceptual method of thinking that was introduced by psychologist Daniel Kahneman in his book Thinking, Fast and Slow. Rather than slow, step-by-step reasoning, System One refers to a mode of thinking that’s fast, intuitive, effortless, and automatic.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;With Jev, you don't get the usual back-and-forth conversation or a lengthy explanation containing the information you need. Instead, you get structured decisions, probability distributions, and confidence scores, all in a structured format/payload.&lt;/p&gt;

&lt;h2&gt;
  
  
  Jev vs. LLMs: What's the Difference?
&lt;/h2&gt;

&lt;p&gt;Now, as I’m sure you’re wondering, what’s the difference? I mean, Jev being a System One model sounds cool and all, but how does that compare to the standard LLMs we know?&lt;/p&gt;

&lt;p&gt;Firstly, let’s talk about the primary output. With regular LLMs, you get open-ended natural language, responses, code, or something similar. The response is in natural-language text and is generated sequentially by the model token-by-token. &lt;/p&gt;

&lt;p&gt;With Jev, however, you get zero natural-language text. Instead, the decision model returns fixed, type-safe (no wonder the company name) structures. These may be predefined choices, numerical scores from 0 to 1, or simply Yes/No probabilities.&lt;/p&gt;

&lt;p&gt;Next, the speed. LLMs usually operate autoregressively, as each generated token depends on the previous ones in a loop-like sequence. As expected, this method of token generation is relatively slow, taking from a fraction of a second to several seconds or minutes, depending on the operation.&lt;/p&gt;

&lt;p&gt;On the other hand, Jev is non-autoregressive and evaluates independent decisions in parallel in a single pass. Instead of writing out a paragraph or parsing JSON, Jev directly maps the input state against predefined choices, scores, or probabilities in one unified evaluation. Hence, it’s quite fast (40x to 200x faster), taking around 70-500 ms (at least according to &lt;a href="https://typesafe.ai/blog/introducing-system-one-models-and-jev" rel="noopener noreferrer"&gt;reports from TypeSafe AI&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;Lastly, and perhaps most importantly, cost. Standard LLMs charge for both input tokens that are processed and output tokens that are generated. For instance, a lightweight model like GPT-4o Mini offers a pricing structure of about $0.15 per 1M input tokens and $0.60 per 1M output tokens ($0.15 / $0.60).&lt;/p&gt;

&lt;p&gt;Now, as I’ve mentioned quite a few times already, Jev doesn’t generate output tokens, so that’s a part of the pricing you don’t have to worry about. For inputs, you get charged $0.042 per 1M tokens processed, making the final pricing structure about ($0.042 / $0.00).&lt;/p&gt;

&lt;h2&gt;
  
  
  Let's Put It to Work
&lt;/h2&gt;

&lt;p&gt;One great way to truly understand how Jev works is by an example I found online: classifying customer support tickets. Now, forgive me for being unoriginal, but if it works, it works.&lt;/p&gt;

&lt;p&gt;Imagine you're building a customer support system for an e-commerce store. Customers submit complaints every day, and someone has to read each one, figure out what it's about, determine its urgency, and route it to the right team. Now, you decide to automate the whole classification process using an AI model to be more efficient as your business grows.&lt;/p&gt;

&lt;p&gt;Consider this ticket:&lt;/p&gt;

&lt;p&gt;"I've been trying to pay for my order since yesterday, but checkout keeps failing. I've also been charged twice, and nobody has responded to my email!"&lt;/p&gt;

&lt;p&gt;With a standard LLM, you send it this ticket alongside a prompt like “You must return valid JSON. Do not include markdown formatting…" or something similar. Then you might need to add a lot more output constraints and validation to get the required information. Plus, the AI might hallucinate more ticket categories or mess up the exact wording, like using “Billing Error” instead of the predefined category “Payment Issue."&lt;/p&gt;

&lt;p&gt;Now with Jev, you get direct classification from a decision model. During setup, you configure Jev with a strictly-typed question schema (using question types such as Choice, Score, or Noul). For our example, we might go with:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;p&gt;Category (Choice): “Payment Issue” - “Technical Issue” - “Shipping Delay” - “Account Lockout” - “Other”&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Urgency Score (Score): 1 to 5 (Routine to Critical)&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Sentiment (Choice): “Positive” - “Neutral” - “Angry”&lt;/p&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Note that this is just a rough template from the top of my head (Don’t judge me)&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;With that, Jev returns structured results that fit the schema we've defined. Since the available choices are predefined, Jev can't return a new category outside the options we've specified for that question. It can still make the wrong classification, though, which is why we need to consider its probabilities and confidence level rather than blindly trusting every result.&lt;/p&gt;

&lt;p&gt;Now, I’m not writing this because normal LLMs can’t stick to strict schemas or always hallucinate. The difference is that Jev is designed around predefined decisions from the start. You're defining the possible answers beforehand, and Jev returns its decision alongside probability information that can help your application handle uncertainty.&lt;/p&gt;

&lt;h2&gt;
  
  
  Are LLMs Becoming Obsolete?
&lt;/h2&gt;

&lt;p&gt;So, are Large Language Models done? Truth be told, that’s what I was thinking about when I first heard of a pure System One AI model that’s significantly faster and cheaper. However, that’s not actually the case.&lt;/p&gt;

&lt;p&gt;Instead, the major shift here is how we separate generative tasks from decision tasks. Using a standard LLM for evaluating data and making decisions from a predefined list can be overkill, especially when we consider speed, cost, and accuracy. As a decision model, Jev is faster, cheaper, and simply better at classification and routing according to strictly set schemas.&lt;/p&gt;

&lt;p&gt;However, Jev isn’t a generative model, so you don’t get anything new like text, prose, or anything like that. For instance, it can’t be used to automatically draft an email to send to customers whose tickets have been analyzed. Obviously, we need standard LLMs for such generative tasks.&lt;/p&gt;

&lt;p&gt;Therefore, the future might be hybrid systems. Decision models can be used to efficiently filter and sort data in a pipeline. A model like Jev could classify incoming requests, filter spam, or determine which workflow should handle a particular task. &lt;/p&gt;

&lt;p&gt;When a request actually needs a human-readable response, a traditional LLM could take over and generate one. It can also be used as some sort of router to determine which tool is best suited to a task, depending on the input provided and the range of available options.&lt;/p&gt;

&lt;p&gt;Rather than treating Jev and traditional LLMs as direct replacements for one another, we can think of them as different components that may work better together.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I Learned
&lt;/h2&gt;

&lt;p&gt;This is probably my longest piece yet, though I consider it worth the effort. What are my key takeaways? Well, now I understand the differences between generative and decision tasks, as I’ve been naively mashing them together. What truly separates Jev from regular models is that it’s configured around our predefined decisions, so we get structured decisions, classifications, and probability scores.&lt;/p&gt;

&lt;p&gt;Keep in mind, though, most of these claims are based on information from TypeSafe AI’s reports. It’s probably best to take them with a pinch of salt until independent benchmarks are available.&lt;/p&gt;

&lt;p&gt;Although AI models keep getting better, it’s quite clear that the brute force approach has its limits. Building specialized models for specific tasks and combining them into a single pipeline could be a more efficient approach, depending on the use case.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>healthydebate</category>
      <category>software</category>
      <category>architecture</category>
    </item>
    <item>
      <title>Monolith or Microservices: One App or Many?</title>
      <dc:creator>Emmanuel Paul</dc:creator>
      <pubDate>Fri, 09 Oct 2026 08:39:30 +0000</pubDate>
      <link>https://dev.to/paul_emmanuel/monolith-or-microservices-one-app-or-many-gid</link>
      <guid>https://dev.to/paul_emmanuel/monolith-or-microservices-one-app-or-many-gid</guid>
      <description>&lt;p&gt;As someone who’s still fairly new to the software industry, I’ve heard a lot of people throw terms like “Monoliths” and “Microservices” left and right. Truth be told, I’ve mostly pretended to know what these words mean, well, until now.&lt;/p&gt;

&lt;p&gt;After spending some time on Google and checking out a few well-written articles, I’ve decided to just write my take on it. Keep in mind, I’m not some expert, so I’m always open to constructive criticisms (not random hole poking) in my logic.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Monolith
&lt;/h2&gt;

&lt;p&gt;Monolithic architecture is pretty much a traditional approach to software development where the entire application is built as a single unified program. Every part of the application, whether it’s the UI, the business logic, or database access, is written within one codebase.&lt;/p&gt;

&lt;p&gt;Based on what I’ve learned, this means the different parts of the application are tightly coupled and typically deployed as one unit. While mixing multiple frameworks or languages is technically possible, doing so can introduce much complexity.&lt;/p&gt;

&lt;h2&gt;
  
  
  Then There's Microservices
&lt;/h2&gt;

&lt;p&gt;If monoliths mean joining everything in one codebase, microservices seem to be the exact opposite. The large application is broken into small, independent services that communicate over a network (APIs, I believe). Each service handles a specific task, which may be processing payments, sending notifications, or simply authentication.&lt;/p&gt;

&lt;p&gt;As services are independent units that simply communicate, they can be written in different languages, depending on their use. For instance, using Python for a service that requires a decent amount of data manipulation and Node.js for a real-time chat service. Plus, if one service fails, the others keep functioning, rather than taking every part of the app down alongside it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What’s The Catch?
&lt;/h2&gt;

&lt;p&gt;If either one of these approaches was perfect, there wouldn’t be much debate between the two. Whether you go for monoliths or microservices, there are a few downsides to consider.&lt;/p&gt;

&lt;p&gt;With monoliths, scaling can eventually become inefficient. Horizontal scaling requires cloning the entire application stack instead of just the limited features, which wastes server resources. Changing the framework or programming language is also nearly impossible once a monolith reaches a massive size. Furthermore, working in one codebase can easily become a nightmare as the engineering team grows, leading to constant git merge conflicts, slow build times, and a slow development cycle.&lt;/p&gt;

&lt;p&gt;When it comes to microservices, you get far more complexity in terms of infrastructure. You may need container orchestration (e.g., with tools like Kubernetes), service meshes, and automated CI/CD pipelines. Besides that, you have to consider network latency, connectivity issues, and securing connections, as various services need to communicate to run the application.&lt;/p&gt;

&lt;h2&gt;
  
  
  Don't Overengineer It
&lt;/h2&gt;

&lt;p&gt;I have quickly become what I call an “expert” in the whole “Monolith vs. Microservices” debate, and here’s my take: Don’t overengineer it. The best software development approach depends on your current needs. If you’re building some kind of MVP or startup project, then just stick to a monolithic architecture, as it is modular and supports rapid early development and simple deployment.&lt;/p&gt;

&lt;p&gt;On the other hand, if you’re scaling an enterprise application, with large distributed teams across several domains, microservices may make more sense. You get the fault isolation, independent scaling capability, and much more flexibility.&lt;/p&gt;

&lt;p&gt;At the end of the day, there’s no universal winner here. Start with what solves your current problem, and let your architecture change as the problem gets bigger.&lt;/p&gt;

</description>
      <category>software</category>
      <category>webdev</category>
      <category>programming</category>
      <category>healthydebate</category>
    </item>
    <item>
      <title>🐾 PawSafe: An AI-Powered Food Safety Checker for Dogs</title>
      <dc:creator>Emmanuel Paul</dc:creator>
      <pubDate>Mon, 17 Aug 2026 00:18:35 +0000</pubDate>
      <link>https://dev.to/paul_emmanuel/pawsafe-an-ai-powered-food-safety-checker-for-dogs-53o8</link>
      <guid>https://dev.to/paul_emmanuel/pawsafe-an-ai-powered-food-safety-checker-for-dogs-53o8</guid>
      <description>&lt;p&gt;&lt;em&gt;This is a submission for &lt;a href="https://dev.to/challenges/weekend-2026-08-13"&gt;Weekend Challenge: Dog Days Edition&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What I Built
&lt;/h2&gt;

&lt;p&gt;PawSafe is an AI-powered web application that helps dog owners answer a simple but important question:&lt;/p&gt;

&lt;p&gt;"Can my dog eat this?"&lt;/p&gt;

&lt;p&gt;Users can enter the name of a food, upload a photo, or provide both. PawSafe then analyzes the information using Google's Gemini API and provides a simple safety assessment.&lt;/p&gt;

&lt;p&gt;The result is categorized into four levels:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;🟢 Generally Safe&lt;/li&gt;
&lt;li&gt;🟡 Use Caution&lt;/li&gt;
&lt;li&gt;🔴 Not Safe&lt;/li&gt;
&lt;li&gt;⚪ Unable to Determine&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Along with the result, PawSafe provides explanations, potential warnings, and safer alternatives when appropriate.&lt;/p&gt;

&lt;p&gt;My goal was to build something that was useful, simple to understand, and approachable for dog owners rather than making users search through multiple sources every time they encounter an unfamiliar food.&lt;/p&gt;

&lt;h2&gt;
  
  
  Demo
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://pawsafe-1.onrender.com/" rel="noopener noreferrer"&gt;Live Demo&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Code
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://github.com/PaulEmmanuel8888/PawSafe" rel="noopener noreferrer"&gt;GitHub Repository&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How I Built It
&lt;/h2&gt;

&lt;p&gt;PawSafe is a full-stack application built with:&lt;/p&gt;

&lt;h3&gt;
  
  
  Frontend
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;React&lt;/li&gt;
&lt;li&gt;Vite&lt;/li&gt;
&lt;li&gt;Tailwind CSS&lt;/li&gt;
&lt;li&gt;Lucide React&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Backend
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Node.js&lt;/li&gt;
&lt;li&gt;Express&lt;/li&gt;
&lt;li&gt;Multer&lt;/li&gt;
&lt;li&gt;CORS&lt;/li&gt;
&lt;li&gt;Google Gemini API&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Deployment
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;Render&lt;/li&gt;
&lt;li&gt;GitHub&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The basic flow looks like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;User
  ↓
Food name / Image / Both
  ↓
React Frontend
  ↓
Express API
  ↓
Google Gemini
  ↓
Structured Analysis
  ↓
PawSafe Result Card
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One of the main technical decisions I made was to keep the Gemini API integration on the backend rather than exposing the API key in the frontend.&lt;/p&gt;

&lt;p&gt;The frontend sends the user's food information to the Express API. The backend then communicates with Gemini and returns the structured analysis to the frontend.&lt;/p&gt;

&lt;p&gt;I also wanted the application to support both text and images independently, while still allowing users to provide both when additional context is useful.&lt;/p&gt;

&lt;h2&gt;
  
  
  Prize Categories
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Best Use of Google AI
&lt;/h3&gt;

&lt;p&gt;PawSafe is submitted for the Best Use of Google AI prize category.&lt;/p&gt;

&lt;p&gt;Google's Gemini API is the core intelligence behind the application. It is used to analyze both text-based and image-based food information and generate a structured safety assessment.&lt;/p&gt;

&lt;p&gt;The AI response is then presented through PawSafe's interface as an easy-to-understand result rather than exposing users to a raw AI response.&lt;/p&gt;

</description>
      <category>devchallenge</category>
      <category>weekendchallenge</category>
      <category>gemini</category>
      <category>ai</category>
    </item>
  </channel>
</rss>
