Next.js¶

React Conferences to attend this month

It's October and I'll be attending two major React-focused conferences this month: React Conf and Next.js Conf. I plan to join both online — which is great because both events offer free virtual attendance. No travel, no hotel, no registration fees — just pick the talks you want to watch and learn.

• React Conf: https://conf.react.dev/
• Next.js Conf: https://nextjs.org/conf

React Conf 2025

React Conf is the official community conference for React. Expect keynote updates from the React team, roadmap discussions, and a broad selection of community talks that cover core React, advanced patterns, rendering strategies, concurrent features, performance, and integrations with modern tooling.

What to expect

• Key announcements from the React team (library improvements, documentations, new APIs).
• Deep-dive talks from community members about patterns, architecture, and real-world solutions.
• Sessions focused on performance, concurrent rendering, and server/edge rendering strategies.
• Practical demos and code samples you can apply to your projects.

How to join

• The livestream and recordings are typically available for free — sign up via the React Conf landing page to get updates and session info: https://conf.react.dev/
• Keep an eye on the schedule and add sessions you care about to your calendar (note the timezone).

Who should attend

• Frontend engineers using React or thinking about adopting it.
• Architects and engineering leads evaluating rendering strategies (client vs. server vs. edge).
• Anyone migrating desktop apps to the web using web-first stacks (React + TypeScript + Next.js).

Next.js Conf 2025

Next.js Conf gathers the broader Next.js community — from hobbyists to enterprise builders. It's focused on things you can actually ship with Next.js: routing and layouts, server components, Incremental Static Regeneration, image optimization, and edge runtimes. This year’s conference also emphasizes AI-driven experiences and performance at scale.

What’s the difference between virtual and in-person

• Virtual: Free access to livestreamed sessions and talks. You can tune in from anywhere; sessions are usually scheduled in Pacific Time (check the site for exact times).
• In-person: Held at The Midway with limited tickets. In-person attendees get access to networking, workshops, and curated interactive experiences (meals and social time are typically included).

How to join

• Register for the virtual stream and see the schedule at https://nextjs.org/conf
• If you attend virtually, plan around the listed timezone (often 9:00 AM to 5:00 PM PT) and bookmark the sessions you don’t want to miss.

Who should attend

• Developers building production apps with Next.js.
• Teams exploring server-side rendering, edge functions, or improving SEO and performance.
• Engineers looking to integrate AI features or optimize delivery with edge platforms.

Tips for getting the most from both conferences

• Review the schedule beforehand and mark the sessions most relevant to your work.
• Watch keynotes live for announcements; catch the recorded talks later for deep dives.
• Try to attend at least one practical session and one architecture/strategy talk each day.
• Save code samples and links from slides to a shared note (use GitHub/Gist or a private repo).
• If timezone makes live attendance hard, prioritize sessions you want to ask questions about and watch the rest on-demand.

Why attending conferences matters (especially for React)

React and the surrounding ecosystem evolve quickly. Conferences are high-density learning events where you: - Learn about new APIs and patterns early, so you can assess adoption risks and benefits. - See real-world use cases and migration paths — invaluable when moving desktop apps to web-based UIs. - Discover performance and accessibility best practices that directly impact production quality. - Get inspired by how other teams solve similar problems (architecture, testing, deployment). - Build awareness around tooling (TypeScript integrations, bundlers, edge runtimes, AI tooling).

Attending — even virtually — helps you and your team stay current and make more informed technical decisions.

Training & Consulting — React, TypeScript, Next.js, and migrations

I offer hands-on training and consulting in: - React and TypeScript best practices (components, typing strategies, state management). - Next.js fundamentals and advanced features (SSR, SSG, ISR, server components, edge functions). - Migration planning and execution for moving desktop applications to the web (UI/UX adaptation, data access, authentication, performance tuning). - Architecture reviews, code audits, and performance optimization workshops. - Short, focused training sessions (half-day or full-day) and longer, project-based engagements.

If you'd like customized training, an architecture review, or help migrating a project, please get in touch via the contact page: /contact/ — or use the contact form on this site to start a conversation about your goals and timeline.

Summary

React Conf and Next.js Conf are both excellent, practical resources for staying up-to-date with the rapidly changing React ecosystem. They offer high-value talks, demos, and announcements — and both provide free virtual options so you can learn without travel. If you want help turning conference learnings into concrete improvements for your projects, I’m available to consult and train your team.

Better-Auth taking over management of Auth.js

I’ve tried a lot of authentication frameworks for React and Next.js in the last year. I wanted something that just works, is secure, and lets me move fast without wrestling with OAuth flows or rolling my own session handling.

For a long time I liked Auth.js (formerly NextAuth.js). It solved many problems out of the box and made it possible to own auth without spending months on integrations. But there were a couple of things that held me back when starting new projects: progress on the project sometimes felt slow to my eyes, and the getting-started documentation could be tricky to follow when you were just learning the library.

Then I learned about Better-Auth — and honestly, I never looked back. Better-Auth felt clearer, more opinionated where it needed to be, and focused on the primitives teams actually reuse. It removed the friction I had with Auth.js when building new apps.

The big news

Last week, there’s been some news that validates that move and makes the ecosystem healthier: Auth.js is now maintained and overseen by the Better-Auth team.

What happened (short summary)

• Auth.js, the project previously known as NextAuth.js, has been handed over to the Better-Auth team for maintenance and stewardship.
• Better-Auth began as an effort to make authentication primitives easier to own and evolve. The two projects share similar goals: reduce friction around OAuth, sessions, and common auth patterns so developers can ship faster and more safely.
• The transition means existing Auth.js users can continue without disruption. Security patches and urgent fixes will be handled, and Better-Auth has published guidance for teams thinking about migration.

Why this matters

• Consolidation: Rather than keeping two competing ecosystems, the stewardship under Better-Auth should help the community converge on a single, more capable solution.
• Roadmap alignment: Better-Auth plans to bring missing capabilities (for example, stateless session support without a database) into its core, which reduces fragmentation and long-term maintenance burden for teams.
• Continuity: If you’re already using Auth.js/NextAuth.js, the immediate work is to keep running as before — the new maintainers will keep fixing security issues and producing migration guides.

My recommendation

• If you’re starting a new project today: consider Better-Auth first. It’s where the active development and direction are headed, and it’s built with the kinds of primitives I keep needing.
• If you maintain an existing Auth.js project: you can continue operating as-is. Check Better-Auth’s migration guide and roadmap if you want to plan a migration — there’s no urgent need to move unless you want the new features.

Final thoughts

Auth.js helped a lot of teams ship real auth quickly. Better-Auth grew out of those same needs and now carries the torch forward. This transition should mean fewer duplicated efforts and a clearer path for teams to own their auth. I’ll be watching the migration guides and trying out new Better-Auth features in upcoming projects.

Need help?

If you’d like help learning how to implement authentication in web applications, I can guide you step-by-step: choosing and configuring an auth library (Better‑Auth, Auth.js, or custom), designing secure session/token flows, and writing example code. I especially enjoy helping teams migrate Delphi desktop applications to the web—I'll map your existing auth and session model to a web-friendly approach, outline a migration checklist, and provide practical tips to avoid common traps.

Send details about your app and requirements and I’ll suggest a concrete plan.

Source of this news

• Better-Auth announcement

Vercel Web Interface Guidelines

Vercel, the company behind the popular Next.js framework, has published a comprehensive set of Web Interface Guidelines. These guidelines provide best practices and recommendations for building modern web applications using Next.js and other web technologies.

They also included their customizations which are specific to Vercel.

Following comprehensive interface guidelines like these is crucial for creating web applications that truly serve their users. Poor user experience design can make even the most powerful applications frustrating and inaccessible, leading to user abandonment and business failure. These guidelines address fundamental UX principles such as accessibility, performance, and intuitive interaction patterns that directly impact user satisfaction and engagement.

Modern web development extends far beyond just making things work—it's about creating experiences that feel natural, inclusive, and delightful across all devices and user capabilities. By adhering to established patterns for keyboard navigation, focus management, loading states, and responsive design, developers can ensure their applications work seamlessly for users with disabilities, on slow networks, and across the diverse landscape of modern devices. This attention to detail not only improves user retention but also enhances SEO performance and reduces support costs.

Key Areas Covered

The guidelines focus on several critical aspects of web interface development:

• Interactions: Keyboard accessibility, focus management, mobile input optimization, and loading states
• Animations: Performance-optimized motion with proper easing and reduced-motion support
• Layout: Responsive design, optical alignment, and safe area considerations
• Content: Accessible typography, proper state handling, and internationalization
• Forms: Input validation, autocomplete integration, and submission handling
• Performance: Rendering optimization, network budgets, and image loading strategies
• Design: Color contrast, shadows, and visual consistency

Vercel-Specific Customizations

Vercel has also included their own brand-specific preferences, particularly around copywriting standards. They emphasize active voice, action-oriented language, consistent terminology, and positive framing of error messages. Their approach prioritizes clarity and conciseness while maintaining encouraging, problem-solving communication even in failure scenarios.

Need help?

Looking to migrate your desktop Delphi applications to modern web technologies? I specialize in helping developers transition from traditional desktop development to web-based solutions using TMS WEB Core, React, or Next.js. Whether you're modernizing legacy VCL applications or building entirely new web interfaces, I can guide you through the process and ensure your applications follow current best practices. You can contact me via my website.

FlexCel is the perfect report generator for any frontend

FlexCel is a powerful library for creating and manipulating Excel files in Delphi and .NET applications. You can export to many image formats as well as PDF files.

The product allows you to create templates in Excel, which makes it easy to design and format reports. You can use all the features of Excel, such as formulas, charts, and conditional formatting. Then, in your backend, you can use FlexCel to populate the templates with data from your database or other sources.

It is currently distributed by TMS Software, a well-known company in the Delphi community. You can find more information about FlexCel on their website. As said, it is available for both Delphi and .NET, so you can use it in various types of applications.

However, this is a major understatement. FlexCel is not just a tool to create Excel files. It is a comprehensive solution for generating reports in various formats, including PDF, images (PNG, JPEG, BMP, GIF, TIFF), and even HTML.

I have been using FlexCel for Delphi and .NET for many years. It is a fantastic library for generating Excel and PDF reports from templates. I have used it in various projects, from small desktop applications to large web services. In my books you can find real-world examples of how to use FlexCel in Delphi applications to create reports. In my latest book about Modern Delphi Application development, I have a whole chapter dedicated to FlexCel and reporting as well as in my book about creating Web Services with XData.

Another Use Case

Recently, I have been working on a Next.js project that required generating complex reports that users had to download as PDF files. I decided to use FlexCel for .NET in the backend, and it worked like a charm. I had two alternatives implementing the backend:

• Using Delphi with WebBroker or RAD Server
• Using Delphi with XData

Both these alternatives would have worked, but I decided to go with ASP.NET Core because I wanted to explore the .NET ecosystem as Microsoft has recently made great improvements with .NET Core to compile for any platform, including Linux and macOS. Also, ASP.NET Core Minimal APIs are very easy to use and get started with.

Deployment Scenario

Deployment is very easy. I picked Linux as the operating system to save costs on hosting. A server that is capable of hosting a Linux ASP.NET Core application is much cheaper than a Windows server. The same is obviously true if you want to host a Delphi application on Windows. Thankfully, Delphi comes with a Linux compiler and both XData and FlexCel support Linux.

To isolate the reporting service from the outside world and only to expose the Web Application, I created a Docker Compose setup with two containers:

• One container for the Next.js frontend
• One container for the ASP.NET Core backend

The two containers communicate via a private network. The Next.js application calls the ASP.NET Core backend to generate the reports. The backend uses FlexCel to create the reports and returns them to the frontend, which then serves them to the user.

The Web Application is accessible via HTTPS, and the backend is only accessible from the frontend container. This setup ensures that the backend is not exposed to the internet, which adds an extra layer of security.

Conclusion

FlexCel is a fantastic library for generating reports in various formats. It is easy to use and integrates well with both Delphi and .NET applications. If you need to generate reports in your application, I highly recommend giving FlexCel a try. You can find more information about FlexCel on the TMS Software website.

Need help?

If you need help with FlexCel, Delphi, .NET, or anything else related to software development, feel free to reach out to me. I offer consulting and training services and would be happy to assist you with your project. You can contact me via my website.

Why Web development is difficult for Delphi developers...

I have been fairly quiet over the past few months, focusing on several projects that required my full attention. Last year, I got to know React and I reported about the challenges.

Coming from a Delphi background, I have learned a great deal about web development and have applied my knowledge of TypeScript and React in real-world scenarios. Some backend functionality is written in Delphi using TMS XData, allowing me to leverage Delphi's powerful database capabilities while utilizing modern web technologies on the frontend.

When building web applications with Next.js, the gap between frontend and backend is narrowing. I can now develop full-stack applications using a single language, TypeScript, which greatly improves efficiency. The learning curve has been steep, but the rewards are significant.

As Delphi developers, we can quickly grasp TypeScript concepts since they are similar to Object Pascal. The tooling is as mature as the Delphi IDE, and the community is huge, with many resources available to help you get started.

The challenges...

The biggest challenge, as I mentioned in my previous blog post, is transitioning to React. Its component-based architecture differs from what we are used to in Delphi, but once you understand it, it becomes a powerful way to build user interfaces.

However, the main hurdle is not the component-based architecture itself, but the fact that React is a JavaScript framework. JavaScript is very different from Object Pascal—the syntax, coding style, and debugging process all differ. TypeScript helps bridge the gap, but learning a new language and framework remains a challenge.

...but they are not too difficult! A new programming paradigm.

React is a declarative, component-based framework for building user interfaces. Instead of writing imperative code to manipulate the DOM, you write declarative code that describes what the UI should look like. This represents a fundamental shift in how we approach UI development.

Consider a pizza restaurant: you order a pizza, and the restaurant prepares it for you. You don't care how the pizza is made; you just want to eat it. In React, you describe what the pizza should look like, and React handles the preparation. In Delphi, it's different—you must instruct the restaurant on how to make the pizza, what ingredients to use, and how to cook it. You control the entire process.

This is known as the declarative programming paradigm. It is a powerful way to build user interfaces, but it requires a different mindset. For me, understanding this paradigm was the most challenging part of learning React. Once you grasp it, the rest is just learning the syntax and framework. The benefit is that you can build complex user interfaces with less code and reduced complexity. Imperative code is often more complex and harder to maintain, while declarative code is easier to read and understand. Today, I would not be able to build a complex UI without the declarative approach.

UI is difficult

Building user interfaces is challenging and requires great attention to detail. In Delphi, we have the VCL and FireMonkey frameworks, which provide a rich set of components for UI development. In React, however, you must build your own components or use third-party libraries, which can be daunting if you are unfamiliar with the framework.

Fortunately, two 'tools' make building user interfaces in React easier:

• Tailwind CSS: A utility-first CSS framework that enables you to build user interfaces quickly and easily. It offers a set of predefined classes for styling components, making it simple to create responsive, modern UIs without writing extensive custom CSS.

• Shadcn UI: A component library that provides pre-built components for React applications. Built on top of Tailwind CSS, it offers components that are easy to use and customize, reducing the need for custom code.

If you are a Delphi developer looking to get into React, I highly recommend using Tailwind CSS and Shadcn UI. They will make your life much easier and help you build user interfaces efficiently.

Writing backend plus frontend code is tedious

Writing backend code in Delphi and frontend code in React can be tedious. You must switch between two different languages, paradigms, and frameworks, which is challenging if you are not familiar with both. Even if you write your backend in TypeScript, you still need to manage two separate projects.

Next.js simplifies full-stack development by allowing you to write both backend and frontend code in the same project using TypeScript. This approach increases efficiency, enables code sharing between backend and frontend, and reduces duplication. You can call backend code from the frontend using Server Actions or API routes, making it easy to build full-stack applications with a single language. Everything is encapsulated in one project, simplifying management and deployment.

Conclusion

In summary, React is a powerful framework for building modern, responsive user interfaces. It requires a new way of thinking about application development, but once you understand it, React offers an efficient approach to UI design. The declarative programming paradigm is the most challenging aspect, but it is also the key to React's power. With Next.js, you can build full-stack applications using TypeScript, streamlining development. Delphi, with TMS XData, provides robust database features that complement modern web technologies. If you prefer, you can also write your backend using Next.js.

Are you ready to dip your toes into something new?

If you’re interested in exploring web technologies, learning React, or building your next application for the web, I’m here to help. Whether you want to modernize parts of your existing solution or start a new project, I offer consulting to guide you through the process and help you master these tools. Let’s connect and take your development skills to the next level!