When it comes to building fast, scalable, and user-focused web applications, Jeremy Millul understands that great performance starts at the API level. As a junior software developer based in Rochester, NY, and a graduate of NYU’s Computer Science program, Jeremy has spent the early years of his career mastering the intricacies of full-stack development—particularly in creating efficient, high-performance RESTful APIs using tools like Node.js and MongoDB.
In this post, Jeremy shares his insights on how developers can optimise performance with RESTful APIs, ensuring that applications respond quickly, scale smoothly, and deliver a seamless user experience.
RESTful APIs serve as the backbone of most modern web applications. They handle the transfer of data between client and server, whether you’re loading a user profile, submitting a form, or pulling up a map location.
“If your API is slow, the entire app feels sluggish—no matter how polished the UI is,” Jeremy explains. “Performance at the backend is just as important as design at the frontend.”
When APIs are not optimised, users encounter frustrating delays, higher bounce rates, and poor engagement. That’s why developers like Jeremy focus on building APIs that are not only functional but lean and responsive under heavy load.
Jeremy recommends using indexed queries and avoiding over-fetching data. “You don’t want your API to return an entire database record when all the user needs is a name and profile picture,” he says. Tools like MongoDB’s projection fields and SQL’s SELECT statements help limit the payload.
He also implements pagination in endpoints that return lists of data. “If your API returns 1,000 results in a single call, that’s going to tank performance. Always paginate.”
To reduce server load and speed up response times, Jeremy sets up server-side caching for commonly accessed endpoints. This includes homepage content, product listings, or settings that don’t change often.
“When a client requests something that rarely changes, there's no need to hit the database every time,” he says. “Using Redis or in-memory caches can dramatically reduce latency.”
Jeremy’s preferred backend stack includes Node.js, which handles asynchronous operations efficiently. “When you're waiting on a database call or an external API, the entire server doesn’t have to freeze,” he explains.
By embracing non-blocking patterns like promises and async/await, Jeremy ensures his APIs stay responsive, even when handling multiple concurrent requests.
“You can’t fix what you don’t measure,” Jeremy insists. He uses tools like Postman, New Relic, and built-in Node.js profilers to measure performance and identify bottlenecks.
“I monitor average response times and error rates. If an endpoint takes 800ms instead of 100ms, that’s a red flag. You need to dig into what’s causing the slowdown—bad queries, slow disk reads, or network latency.”
In one of his freelance projects, Jeremy helped a small business platform cut their API response times by 40%, simply by restructuring their database queries and adding caching. This resulted in a better user experience and a measurable increase in customer engagement.
“The frontend didn’t change, but users noticed it loaded faster and felt smoother,” Jeremy recalls. “That’s the power of a well-optimised backend.”
Performance is not an afterthought—it’s a core part of building great software. Jeremy Millul’s approach to API development shows that a thoughtful, data-driven strategy can significantly improve how applications behave in the real world.
“I love creating things that feel fast and effortless,” Jeremy says. “When the technology disappears and the experience just works—that’s the goal.”
