Forem: Jane

TOP 5 Books Every Backend Developer Should Read

Jane — Fri, 10 Apr 2026 10:00:30 +0000

The world of software development is fast-paced. If you glance away to pet your cat too long, you may miss the next big framework or tool. For instance, JavaScript, one of the most popular programming languages in the world, is notorious for pushing out new frameworks as often as a developer has a bad day , which happens more often than you may think. Because of this, many developers need to get information quickly, and the best mediums to get that information come in the form of short-form videos, quick articles, and snappy courses. While we can appreciate the roles these play in keeping us up to speed with development trends, it’s still crucial to settle in with a good book once in a while.

Some development books may seem intimidating judging by volume alone, but the treasures they hold within are timeless. Usually, what separates good developers from average developers is how much time they are willing to read between the lines and understand the underlying concepts that run programs, so they can be more efficient at solving problems. If you’d like to be the best backend developer you could be, have a look at these top five books backend developers should read that’ll be sure to take you to the next level of your career.

1. Designing Data-Intensive Applications by Martin Kleppmann

This book is a classic for those seeking to understand how data works and is handled by applications. It dives into ways to optimize data, so you produce programs that retrieve and use data quickly and efficiently.

Here, you’ll be looking into database storage and trade-offs that exist between different data technologies. It introduces these core trade-offs in distributed systems like consistency, availability, and scalability, which shape how real-world backend systems are designed. As a backend developer, dealing with data constantly, this book is a must-have and will help you explore the fundamental principles of data systems.

2. Clean Code by Robert C. Martin

Clean code is a tricky subject. After a few years in development, you realize that there are certain standards that must be upheld in your code, but you also become aware that these same standards and best practices are not set in stone and may be broken on occasion. An example is the DRY principle. You may know that repeating code is bad practice, but would you stick to this rule so much, at the expense of readable code? That’s where Clean Code by Robert C. Martin saves the day. It dives into such questions and explains what it truly means for code to be clean.

Robert’s book emphasizes that writing clean code isn’t about unbending rules, but about making thoughtful decisions in matters of readability, maintainability, and practicality.

You’ll learn about writing code that is self-documenting, keeping functions focused on one thing and other such rules for maintainable, readable and modular code. Rid yourself of code smells, and get a copy.

3. Cracking the Coding Interview by Gayle Laakmann McDowell

Coding interviews are not a walk in the park. In some cases, the questions you may face in a technical interview may seem quite abstract and sometimes a bit different from what you deal with at work in your day-to-day. If you’re thinking of taking a bold step into job searching, this book is a classic and a must-have in your preparation attempts.

Beyond just practicing interview questions, it’ll help you build a problem-solving mindset. Solve over 180 coding questions and find yourself walking confidently in and out of technical interviews.

4. Fundamentals of Software Architecture by Richard and Ford

This book is a haven for those seeking a good introduction to Software Architecture fundamentals. It discusses eight architectural styles, each with detailed explanations. It explains how different architectural styles impact system performance, scalability, and maintainability, which are key concerns in backend development. It could serve as a great handbook and source material for all things architecture-related.

5. Grokking Algorithms by Aditya Bhargava

This book is a delight. It makes algorithms easier to follow and visual learners would benefit greatly from the illustrations. In it, Aditya simplifies concepts like Big O Notation, recursion and dynamic programming.

On reading this book, you’ll realize soon enough that it makes complex algorithmic concepts intuitive, helping developers understand not just how solutions work, but why they work. The author makes these rather abstract concepts easier to mentally navigate with his witty and brilliant writing.

Conclusion

The above are just a few of many interesting and amazing books that will keep you deeply engaged. While some of the books on this list aren’t specifically targeted at backend developers, they are great to have in your library as they concern general coding best practices and critical thinking.

Why not pick up a book today? Perhaps lose yourself in the whimsical world of Grokking Algorithms, be amazed by how Martin Kleppman explains the secret recipes needed in designing data-intensive applications, or carefully observe and craft your methods after reading Robert C. Martin’s Clean Code.

Have a great one!!!

Author: Amanda Ene Adoyi

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Persistent Chat History with Database Design (Practical Example)

Jane — Thu, 09 Apr 2026 10:00:30 +0000

Chat applications look simple on the surface when you look at them. But behind every smooth conversation, there is a system that stores, retrieves, and manages messages efficiently.

What makes modern apps usable is the persistent chat history. A lot of users would expect conversations to load instantly, stay in order, and remain available across all their devices; that only works when the database design is done in the right way.

This guide focuses on how persistent chat history works in a real system, and how conversations, users, and messages are structured step by step to keep your application responsive, organized, and ready for real-world use.

Example Schema for a Chat Application

To ensure you have a strong chat schema, you must begin with three main entities: users, conversations, and messages. Keeping these entities separate makes the system easier to scale, query, and maintain.

At the very least, you need a users table or collection that helps store identity and basic profile data.

{
  "user_id": "u123",
  "username": "john_doe",
  "created_at": "2026-01-01T10:00:00Z"
}

Next is the conversations entity , which represents the chat thread between two or more users. It acts as the container for messages.

{
  "conversation_id": "c456",
  "participants": ["u123", "u789"],
  "created_at": "2026-01-01T10:05:00Z"
}

This structure allows group chats and one-on-one chats without changing the schema.

The most important part is the messages entity. Each message belongs to a conversation and a sender, which is where most queries will happen, and it’s meant to be designed carefully.

{
  "message_id": "m001",
  "conversation_id": "c456",
  "sender_id": "u123",
  "content": "Hello, how are you?",
  "timestamp": "2026-01-01T10:06:00Z"
}

Always include a timestamp; the ordering of the message depends on it. Also, having a relational database can be translated into three tables:

users (user_id, username, created_at)
conversations (conversation_id, created_at)
messages (message_id, conversation_id, sender_id, content, timestamp)

A joint table like conversation_participants is always needed to map users to conversations:

This helps to avoid duplicating participant data and keeps relationships flexible.

Create indexes on:

conversation_id i n the messages table for fast retrieval
timestamp for ordered queries
sender_id for filtering user messages

Not having a proper index can lead to the chat queries slowing down quickly as soon as data grows.

And for NoSQL databases like MongoDB, you can use a similar structure with collections:

users
conversations
messages

Or you can embed messages inside conversations for smaller apps:

{
  "conversation_id": "c456",
  "participants": ["u123", "u789"],
  "messages": [
    {
      "sender_id": "u123",
      "content": "Hello",
      "timestamp": "2026-01-01T10:06:00Z"
    }
  ]
}

Embedding works well for smaller volume chats. For high-scale systems, you’ll need to separate message collections to improve performance.

Add optional fields to support real-world features:

status (sent, delivered, read)
edited_at (for message edits)
deleted_at (for soft deletes)
attachments (for media support)

Keeping the schema flexible is important, but try as much as possible to avoid overloading it early. Start simple and extend only when needed.

Sample Data Model for Conversations and Messages

Having a good data model defines how conversations and messages relate, how they are queried, and how they scale under load.

Start with a conversation-centric model. Every message belongs to a conversation, and every conversation has participants.

Example:

{
  "conversation_id": "c001",
  "type": "group",
  "participants": ["u1", "u2", "u3"],
  "last_message_id": "m045",
  "created_at": "2026-01-01T10:00:00Z",
  "updated_at": "2026-01-01T10:10:00Z"
}

The last_message_id is important because it allows quick previews without scanning all the messages, and that is how chat lists load fast in real apps.

Let’s now define the message model. Each message is stored independently and linked to its conversation.

{
  "message_id": "m045",
  "conversation_id": "c001",
  "sender_id": "u2",
  "content": "Let’s deploy today",
  "timestamp": "2026-01-01T10:09:00Z",
  "status": "delivered"
}

Avoid updating message content frequently; it keeps the system predictable.

Add a sequence or ordering field when strict ordering is required.

"sequence": 45

Timestamps can collide in high-throughput systems, and a sequence number guarantees correct ordering, especially in distributed setups.

For relational databases, the model translates into:

conversations
messages
participants

Each table has a clear role. Queries stay simple and efficient.

Example:

SELECT * FROM messages
WHERE conversation_id = 'c001'
ORDER BY timestamp ASC
LIMIT 50;

In NoSQL systems, the model is somewhat similar but optimized for access patterns. Messages stay in a separate collection for scalability, and conversations store lightweight metadata only.

For high-performance systems, denormalization helps to store frequently accessed data, such as:

last message content
unread message count
last active timestamp

directly in the conversation object.

{
  "conversation_id": "c001",
  "last_message": "Let’s deploy today",
  "unread_count": {
    "u1": 2,
    "u3": 1
  }
}

This avoids expensive joins or aggregations during reads.

Designing for pagination from the start is very important. Offset-based pagination tends to break at scale. Use cursor-based pagination instead, typically with timestamp or message_id.

GET /messages?conversation_id=c001&before=m045&limit=20

This keeps queries fast even with millions of messages.

Also, support additional fields without breaking the model:

attachments for media
reply_to for threaded replies
metadata for AI-generated context or tags

Having a clean data model balances structure and flexibility. When conversations and messages are modeled correctly, the performance, scaling, and feature development become easier to manage.

Writing and Reading Chat Messages Step by Step

Writing and reading chat messages are meant to be simple, fast, and consistent. Every step taken must be predictable, especially when under high traffic.

When a user sends a message, the system receives a request with key fields like conversation_id, sender_id, and content. It validates these inputs first, then rejects empty messages or invalid conversation IDs early.

It also generates a unique message_id. which can be a UUID or a database-generated ID, and also attaches a timestamp and, if needed, a sequence value for strict ordering.

{
  "message_id": "m101",
  "conversation_id": "c001",
  "sender_id": "u1",
  "content": "Message received",
  "timestamp": "2026-01-01T10:15:00Z"
}

Then insert the message into the database.

In a relational database, wrap it in a transaction if multiple tables are updated, while in NoSQL systems, ensure the write is acknowledged before proceeding. Be sure to update the conversation metadata immediately after.

This typically includes:

last_message_id
last_message optional preview
updated_at timestamp

This ensures that the chat lists reflect the latest activity without querying the messages table.

Example:

UPDATE conversations
SET last_message_id = 'm101',
    updated_at = NOW()
WHERE conversation_id = 'c001';

If the system supports unread counts, then the increment counters for other participants. This helps to reduce the recalculating counts during reads.

The most common operation is fetching messages for a conversation. Always send a query using conversation_id and sort by timestamp or sequence.

SELECT * FROM messages
WHERE conversation_id = 'c001'
ORDER BY timestamp DESC
LIMIT 20;

Make use of pagination and never load all messages at once.

Cursor-based pagination works best at scale. Instead of offsets, be sure to use a reference point like message_id or timestamp.

GET /messages?conversation_id=c001&before=2026-01-01T10:15:00Z&limit=20

This keeps performance stable even with a large dataset.

Be sure to reverse the result set on the client if needed. Most databases tend to return recent messages first for efficiency.

After writing a message, publish an event (via WebSocket or message queue). It helps to push new messages to connected clients without polling the database.

Ensure that writes are visible to reads immediately or within an acceptable delay. Efficient write and read paths are the pillar of any chat system. If any of these steps are optimized, the whole messaging experience feels instant and reliable even as the data grows.

Optimizing Queries for Real-Time Chat Apps

Real-time chat performance depends heavily on how the queries are written and how they are being executed. Slow queries lead to delayed messages, laggy interfaces, and poor user experience.

The most important query in any chat app is fetching messages by conversation_id. Without an index, this becomes a full table or collection scan.

Create indexes on:

Example, in SQL:

CREATE INDEX idx_conversation_timestamp
ON messages (conversation_id, timestamp DESC);

This allows fast retrieval of recent messages without scanning the entire dataset.

Only select the fields needed for rendering messages. Pulling large payloads (like attachments or metadata) when not required increases latency and memory usage.

Smaller result sets mean faster queries.

Offset queries tend to slow down as data grows because the database still scans skipped rows.

Bad approach:

LIMIT 20 OFFSET 10000;

Better approach:

WHERE timestamp < '2026-01-01T10:15:00Z'
ORDER BY timestamp DESC
LIMIT 20;

This keeps the performances consistent, even with millions of messages.

Chat lists and recent messages are requested often. Use in-memory stores like Redis to cache:

Last messages per conversation
unread counts
active conversation lists

This reduces the database load and improves the response time.

Instead of joining multiple tables for every request, store frequently needed fields directly in the conversation record, and if multiple conversations need to be loaded, fetch them in a single query instead of multiple round-trip requests.

Always filter by conversation_id or user context. Unbounded queries tend to increase load and expose unnecessary data.

A query that works with 1,000 messages may fail at 1 million. So be sure to simulate large datasets early to identify bottlenecks before they reach production.

When queries are optimized, messages load instantly, scrolling feels smooth, and the system scales without you constantly rewriting it.

Have a great one!!!

Author: Toluwanimi Fawole

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Authentication & Session Management for AI Apps

Jane — Wed, 08 Apr 2026 10:00:30 +0000

AI applications don’t just help to process data; they interact with users, agents, and external services. This could either be a human user logging into a chatbot or an AI agent calling another service. Without having proper authentication, AI APIs become vulnerable to misuse or unauthorized access.

When users log into an AI-powered product, the system needs to verify identity, manage access permissions, and maintain conversation or activity sessions, which is important for AI apps that handle chat interactions, autonomous agents, or high-volume API requests.

This guide breaks down how authentication works in AI applications and how to manage sessions securely at scale.

API Key Authentication for AI Services

API key authentication is one of the most common ways to secure AI services and machine learning APIs, and it works by assigning a unique key to each client, application, or developer account. Every request sent to the AI service must include the key so the server can verify access.

The API key acts as a simple credential, and when a request reaches the server, the service checks the key against the stored records. If the key is valid, the request proceeds to the AI model or processing pipeline.

A typical example looks like this:

POST /v1/inference
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Some APIs accept the key through a custom header:

x-api-key: YOUR_API_KEY

Once it has been verified, the service processes the request and returns the model output.

API keys are widely used in AI platforms because they are very easy to generate, distribute, and revoke. This makes them a practical option for developer-facing AI services, internal microservices, and early-stage AI products.

They are mostly common in:

Machine learning inference APIs
AI-powered developer platforms
internal AI microservices communicating with each other
automation tools that interact with AI endpoints

Security practices matter a lot when using API keys. Keys should never be stored in client-side code or a public repository. Exposing a key in frontend JavaScript or committing it to version control makes it easy for attackers to copy and misuse.

Instead of doing that, store the keys in environment variables or secure a configuration system whereby whenever a backend service needs the key, it retrieves it from the environment rather than hardcoding it.

Key rotation is very important; generating new keys and deactivating old ones reduces long-term risk if a credential leaks. And if a compromised key suddenly generates thousands of requests per minute, the system should throttle or temporarily block the activity.

Despite their simplicity, API keys have limitations, and they identify the calling application but do not inherently represent a user identity or permission scope, simply because a lot of production AI platforms combine API keys with additional security layers such as usage quotas, IP restrictions, or token-based authentication.

But when implemented correctly, API key authentication helps to provide an effective way to secure AI services while also keeping integration simple for developers.

Token-Based Authentication Using JWT

Token-based authentication is mostly used in modern AI APIs and applications. Instead of you sending login credentials with every request, the system issues a token after the user successfully authenticates, and one of the most common formats is a JSON Web Token (JWT).

A JWT is more like a compact URL-safe token that contains encoded information about the authenticated identity. It includes user details, permissions, and an expiration timestamp. The token is digitally signed just so the server can verify its authenticity without it needing to store session data.

Some typical examples of JWT authentication workflow are:

When a user or service sends login credentials to an authentication endpoint.
When the server verifies the credentials.
When the server generates a signed JWT.
When the client includes the token in future requests to protected endpoints.

Most APIs expect the token in the Authorization header:

Authorization: Bearer YOUR_JWT_TOKEN

When a request reaches the AI service, the backend verifies the token signature and checks its expiration time. If the token is valid, then the request proceeds to the AI model or application logic.

JWT tokens are mostly used in AI platforms that support user accounts, dashboards, or role-based access control.

JWTs consist of three parts separated by periods:

HEADER.PAYLOAD.SIGNATURE

The header describes the signing algorithm
The Payload contains claims such as user ID, role, and expiration time
The Signature verifies that the token was issued by a trusted authority

Simply because the token is signed, the server can verify it without storing session data in a database, which makes JWT authentication stateless, ideal for scalable AI systems and microservice architectures.

Stateless authentication helps to simplify horizontal scaling when multiple AI API instances are running behind a load balancer; any instance can validate the token without needing shared session storage.

JWTs typically include an exp claim that helps to define when the token becomes invalid. Short-lived tokens reduce security risk if a token is intercepted or leaked.

A lot of systems also issue refresh tokens. When an access token expires, the refresh token can request a new one without forcing the user to log in again. When using JWT authentication, security best practices are important

Always sign tokens using strong algorithms such as HS256 or RS256. Never trust an unsigned token or a token created on the client side.

Sensitive information should not be stored inside the token payload. Even though JWTs are signed, they are not encrypted by default.

For web applications, storing tokens in secure HTTP-only cookies helps reduce exposure to cross-site scripting attacks.

In AI applications, JWT authentication works well for:

AI dashboards with authenticated users
Multi-tenant AI platforms
AI-powered APIs that enforce user roles
Microservices communicating with each other

When implemented correctly, JWT-based authentication provides a scalable and secure identity mechanism for modern AI applications while also keeping request handling fast and stateless.

OAuth and Social Login for AI Platforms

In AI platforms, OAuth and social login simplify account management while improving security.

Instead of storing passwords directly, the AI application helps by delegating authentication to an external provider. Common providers include Google and GitHub. The application receives a secure access token that verifies the user’s identity.

A typical OAuth flow looks like this:

A user clicks a social login option (for example, “Sign in with Google”).
The application redirects the user to the identity provider.
The provider verifies the user’s identity.
The provider returns an authorization token to the AI platform.
The AI application creates a session or issues its own internal access token.

This approach helps to remove the need to manage passwords directly. Password storage introduces security responsibilities like hashing, credential rotation, and breach mitigation. OAuth helps to shift those responsibilities to specialized identity providers.

OAuth is useful for AI platforms that target developers or teams. Take for example, an AI code assistant might allow developers to log in using GitHub accounts, and once authenticated, the platform can securely access repository metadata or integrate with development workflows.

OAuth supports scopes that help define exactly what an application is allowed to access. Instead of granting full account control, a user might allow an AI app to read profile data or access specific resources.

OAuth also helps to improve onboarding speed. Users can sign in with existing accounts in seconds instead of filling out registration forms, which helps to reduce friction, particularly important for consumer AI applications.

When implementing OAuth, security practices still matter. Always validate authorization tokens on the backend server and never rely solely on client-side verification. It is important to store minimal identity information locally, and in most cases, the AI platform only needs a unique user ID and basic profile data from the identity provider.

For AI systems that interact with external services, OAuth can also enable secure API integrations. The same goes for AI platforms with user accounts, dashboards, or collaborative tools. OAuth and social login provide a secure and scalable authentication method while also reducing the complexity of managing passwords internally.

Passwordless Authentication for AI Apps

Passwordless authentication helps users to access an AI application without you creating or entering a traditional password. What it does is, the system verifies identity using alternatives such as magic links, one-time passcodes (OTP), biometric authentication, or hardware security keys.

This approach is becoming very popular because passwords are now a major security weakness. Removing passwords reduces risks like credential reuse, phishing, and weak password selection.

For example, a common workflow uses email magic links:

The user enters an email address.
The AI application generates a temporary login link.
The link is sent to the user’s email.
Clicking the link verifies identity and creates a session.

Another common method used is a one-time passcode sent through email, SMS, or an authenticator app. The user enters the code within a short time window, and the system validates it before granting access.

These methods work well for AI platforms that prioritize fast onboarding, removing the need to create and remember passwords, which reduces friction and can improve user adoption for consumer-facing AI tools.

Passwordless authentication is useful for:

AI chat platforms
AI productivity tools
developer-facing AI dashboards
internal AI tools used by teams

Modern passwordless systems often rely on WebAuthn or FIDO2 standards. These technologies support biometric authentication through devices such as fingerprint scanners or facial recognition built into phones and laptops. Instead of transmitting a password, the device verifies the user locally and signs a cryptographic challenge.

This provides strong protection against phishing attacks because authentication is tied to the user’s device and domain.

Developers building AI applications should also consider session handling after authentication succeeds. Even without passwords, the system still needs a secure session token or an access token to maintain the user’s authenticated state during API requests.

Passwordless authentication offers a secure and user-friendly approach for AI applications, as it tends to reduce credential risks while keeping login flows simple for users interacting with modern AI services.

Have a great one!!!

Author: Toluwanimi Fawole

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Top 5 Java Backend Development Courses (2026)

Jane — Fri, 20 Mar 2026 10:30:00 +0000

The internet is filled with lots of Java Backend Development Courses. Therefore, choosing the best Java backend development course can be a nightmare for newbies looking to start or change careers.

Java is a popular programming language with a ground-breaking of millions of developers worldwide, with over 7.1 million professionals using it to build robust applications. Also, Java runs on over a billion devices according to Oracle.

This groundbreaking record shows the value and relevancy of learning Java today as a backend engineer. You must choose the Best Java Course this year to achieve this goal effectively. A course that is designed to teach you the basics and also prepare you for the real challenges in your tech journey.

If you’re planning to start your Java backend development journey, investing in the right Java Backend Development course could be the key to your success.

To help reduce the time spent researching and searching for the best backend development course, we have already prepared a list of the top five best Java backend development courses. These courses are thorough, beginner-friendly, and will prepare you for the job market.

As part of our criteria, we have assembled the best course to learn Java for Backend Development. These courses combine the right essential theories, including practical projects, while making learning enjoyable and effective.

Additionally, these top-rated courses boast a 90% satisfaction rate from participants because they prepare them for the job and cover almost everything needed to become a Java Backend Developer.

Top 5 Java Backend Development Courses 2025

Here’s a comprehensive guide to the Top 5 Best Java Backend Development Courses for 2025. These courses are called Roadmap Java Backend Courses, designed to take you from a complete beginner to a different level of expertise.

Become a Java+Spring Backend Developer.
Mastering Java Backend with Oracle University.
Learn Java by Creating Applications.
Become a Java Backend Developer Bootcamp
Building Scalable Java Microservices with Spring Boot and Spring Cloud

1. Become a Java+Spring Backend Developer

The course takes you from ground zero and gradually moves you to become proficient in Java Backend Development.

Below are the modules covered in this course:

Java Essentials: The Java Essentials module is a complete, beginner-friendly course that explains the Core Java Basics, Object-Oriented Programming, Java syntax, and concepts such as variables, data types, arrays, strings, functions, control flow in Java, and error handling. This 49-video lesson course will expose you to core Java basics, Object-Oriented Programming, and Error Handling in Java.
Advanced Java: As the name suggests, this is a complete advanced Java course that aims to teach you advanced concepts in Java, such as Collections, Java I/O Streams and Build Tool, and Multithreading in Java. This course explores I/O streams, collections, build tools, and multithreading in great detail, giving you the required knowledge to excel in Java Backend Development.
Design Patterns in Java: In this module, you will learn the significance of design patterns and how to apply key Creational, Structural, and Behavioral patterns to create robust, maintainable, and scalable Java software solutions.
Unit Testing in Java: In this module, you will learn the importance of unit testing, the principles of Test-Driven Development (TDD), how to write test cases using JUnit, how to utilize advanced JUnit features like parameterized tests and test suites, and how to implement mocking with Mockito.
Spring Framework and Spring Boot: In this module, you’ll begin with the essentials of the Spring Framework, exploring how to configure beans using annotations and XML, manage bean lifecycles, and tap into Spring’s modular ecosystem, including AOP, Spring MVC, Spring Batch, Integration, and JMS. As you progress, you'll dive deep into security, messaging, and cloud support through Spring Security and Spring Cloud.
Microservices in Java: You will learn about the benefits and challenges of Microservices Architecture, how to build and configure microservices with Spring Boot, enable communication between microservices using Feign Client, implement event-driven messaging brokers, configure service discovery and registration with Eureka, and utilize API Gateway and load balancing with Zuul, Spring Cloud Gateway, and Ribbon.
Containerization: In this module, you'll learn to use Docker and Kubernetes by containerizing a Java application, working with Docker images, containers, registries, Dockerfiles, and Docker Compose, then dive into Kubernetes architecture and components like Pods, Nodes, and Clusters, set up clusters with Minikube and AWS, manage resources such as Deployments, Services, Ingress, ConfigMaps, and Secrets, scale applications, and implement monitoring and logging.
Milestone Projects in Java: Build over 10+ projects while learning Java. Build a SaaS product in Java.

It is an all-in-one Java and Spring course for learning backend engineering with Java. This comprehensive course is designed for Java developers seeking proficiency in Java.

Course Highlights:

Lifetime access to course materials
Dedicated doubt resolution sessions
Industry-oriented curriculum following the Roadmap.sh
Live sessions and webinars with industry experts
Certification upon completion
Real-world projects and case studies

Course Duration: 2-4 months.

Course Price: starting at $60 monthly.

Course Link: https://masteringbackend.com/courses/become-a-java-spring-backend-engineer

2. Mastering Java Backend with Oracle University

This is the official Java course from Oracle University. Java is currently owned by Oracle Corporation, which acquired Sun Microsystems, the original developers of Java.

However, the Java core specification is managed through the Java Community Process (JCP), and Oracle owns the official Java Standard Edition (SE) implementation.

The Oracle University has created a series of Java courses to help you develop in-demand programming skills with comprehensive training on the latest Java technology.

Below are some of the Java Backend Development Courses from Oracle University:

Java Explorer: Learn the basics of Java, such as variables, loops, objects, classes, arrays, and decision-making constructs.
Java SE 11: Programming Complete: This course is intended for students with some programming experience and is a comprehensive training for Java developers.
Developing Applications for the Java EE 7 Platform: This course teaches you how to build and deploy enterprise applications with Java EE.
Architect Enterprise Application with Java EE: This course teaches you how to develop robust architectures for enterprise Java applications.

The Oracle University is a subscription-based platform; you can access most of the courses when you subscribe. Also, you can access certification courses from the university and earn a recognized certificate from Oracle.

3. Learn Java by Creating Applications

This is an official course from JetBrains, the creators of JetBrains IDEs and the Kotlin programming language. It teaches Java development practically by building chatbots, games, algorithms, and even neural networks from scratch.

The course is subdivided into tracks to help you gradually expand your knowledge and improve in the areas that interest you.

Below is a list of the tracks:

Java for Beginners: This course is for complete Java beginners and programming newbies. Its track will help you start and prepare for some computer science certifications.
Java Core: This track is a great choice for learners who want to gain a firm grasp of Java fundamentals and be introduced to algorithmic problems and mathematical models.
Java Backend Developer: This track was specifically designed to prepare you for your first Junior Developer interview. It contains tasks necessary to successfully pass your technical interview.
Java Desktop Application Developer: If you already know the basics of Java and would like to create desktop apps, this is the right track for you. You will also master the Swing framework.

Course Highlights:

200+ interactive projects
Personalized study plan
Integration with JetBrains IDEs
Knowledge map
Instant feedback
Certificate of completion

4. Become a Java Backend Developer Bootcamp

All-in-one Java Bootcamp for learning backend engineering with Java. This bootcamp is designed for Java developers seeking proficiency in Java.

The Java Backend Developer Bootcamp is a comprehensive backend engineering bootcamp that will equip you with the skills to take your backend engineering career to the next level.

Bootcamp Outline:

Below is the content outline that we cover in this bootcamp to turn you into a great backend developer using the Java programming language.

Basics of Back-End Development
Server-side Programming Language (Java)
Build a Back-End with Spring
API and API Design
Git and GitHub
Mastering Database
Deployment
Software Testing
Software Design Principles
Web Security
Caching and CDNs
Message Brokers and Search Engines
Scalability
Containerization and CI/CD
Data Structures and Algorithms
What to Expect in a Technical Interview (Landing Job)

Bootcamp Highlights:

200+ recorded videos and lessons
Personalized study plan
3-month access to the instructor
Lifetime Access and updates
Practice Projects
Career Services
Instant feedback
Certificate of completion

Course Duration: 2-4 months.

Course Price: starting at $500 monthly.

Course Link: https://academy.masteringbackend.com

5. Building Scalable Java Microservices with Spring Boot and Spring Cloud

Are you a Java developer looking to take your microservices skills to the next level? Google Cloud, in collaboration with Coursera, offers an intermediate-level course that teaches you how to build scalable, cloud-native microservices using Spring Boot and Spring Cloud.

In this course, you'll learn how to:

Build Spring Boot microservices that integrate with Google Cloud managed services
Use Pub/Sub and Spring Integration for message handling
Store data with Cloud SQL and migrate to Cloud Spanner
Implement distributed tracing using Cloud Trace

This course is perfect if you already have some experience with Java and want to deepen your skills by working with real-world cloud tools.

Course Highlights:

3 hands-on modules
Approx. 12 hours of content — learn at your own pace
2 assignments to test your knowledge
A shareable certificate for your LinkedIn or resume
Lifetime access via Coursera Plus

The course is taught by instructors from Google Cloud, who bring real-world expertise and practical examples to every lesson.

Final Thoughts

Choosing the right Java backend development course in 2025 is more than just selecting a popular program — it's about finding the one that aligns with your learning style, career goals, and current experience level. Whether you're a complete beginner starting from scratch or a developer looking to deepen your expertise, the courses listed above provide a comprehensive roadmap to mastering Java for backend engineering.

From industry-aligned programs like "Become a Java + Spring Backend Developer" by Masteringbackend to practical, hands-on courses from Oracle University, JetBrains, and Google Cloud, these options are carefully curated to help you build real-world skills and become job-ready. Each course combines structured modules, project-based learning, expert-led instruction, and certifications that can give you an edge in today’s competitive job market.

Now is the best time to invest in your backend engineering career. Choose the course that suits you best and take the first step toward becoming a professional Java Backend Developer in 2025.

Ready to Become a Java Backend Engineer?

If you're serious about launching your backend engineering career with Java, then Become a Java+Spring Backend Developer is the ultimate course to get you there.

With a structured roadmap, real-world projects, and modules that take you from complete beginner to job-ready backend engineer, this course is your all-in-one solution. You'll learn everything from Java fundamentals to advanced Spring Boot microservices and even containerization with Docker and Kubernetes.

Lifetime access
Hands-on projects
Live sessions with experts
Certification on completion
Designed by backend engineers for backend engineers

Join thousands of developers already learning Java the right way.

Start Learning Today — and build your future in backend engineering!

Have a great one!!!

Author: Solomon Eseme

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Which AI Skills Actually Get You Hired in 2026?

Jane — Thu, 19 Mar 2026 17:00:00 +0000

I've been thinking a lot about the AI job market lately.

Everyone says "learn AI", but which skills actually matter?

After talking with hiring managers and seeing what's actually in demand, here are
the 3 skills that separate candidates:

RAG Implementation — Real document processing and vector databases, not just API calls
AI Observability — Tracking and debugging AI systems in production
Cost Optimization — Making AI affordable to run at scale

Notice what's NOT on this list? "Prompt engineering." Everyone claims that.--

If you want to go deeper, I'm hosting a free workshop this Saturday with Victor
Eduoh from Laand.

"How to Land AI Engineering Jobs."

Saturday, March 22nd. 4 PM UTC. Free.

Register here: http://lu.ma/mb-events

Even if you never take my bootcamp, this workshop will change how you approach AI
jobs.

Spring Boot + Redis + Docker: Ultimate Guide to Caching in Java

Jane — Thu, 19 Mar 2026 10:30:00 +0000

With Redis, your Spring Boot app can become faster and handle more traffic without breaking a sweat. This article will show you how to set it up step by step. However, before diving deep into Redis, we need to understand the concept of caching.

What is Cache?

Cache is a fast, small, temporary storage frequently used by the computer or application to store and access important data.

It stores data in a key-value format. By leveraging cache memory, we can minimize database calls, improving application performance since database queries are typically resource-intensive.

The main objective of a cache is to speed up the retrieval of data by making a copy of the data in a location that can be accessed faster than the source or database.

A cache is a small and fast, and efficient memory space that an application frequently uses to store or access important data.

Why Caching?

The main objective of a cache is to speed up the retrieval of data by making a copy of the data in a location that can be accessed faster than the source or database.

In our application, whenever multiple requests access static data (data that is not changed frequently), we fetch the data from the database every time. Therefore, the number of database calls increases, which affects the performance of our application because database calls are always costly.

However, the static data can be stored in a cache, and whenever a request is made to access the data, it is fetched from the cache. As a result, the number of database calls is reduced, and the application's performance is improved.

How does a Cache work?

In the diagram above, multiple requests made to access the data in the application will first check the cache to determine whether the data is present. If the data is found, it is returned from the cache, a concept known as a Cache Hit. If the data is not found, it is retrieved from the database, which is referred to as a Cache Miss.

Cache Hit

Data is found in the cache, so it has to be fetched from a faster source.

We can understand the cache hit like this: imagine you have a notebook where you write down answers to questions you frequently ask. You ask a question, and the answer is already written in your notebook. You quickly find it without searching elsewhere.

Cache Miss

Data is not found in the cache, so it has to be fetched from a slower source.

Similarly, you asked a question, but it’s not in your notebook. You have to search in a big textbook (which takes more time) and then write the answer in your notebook for future use.

Redis

Redis (Remote Dictionary Server) is an open-source, in-memory key-value data store that supports various data structures, including strings, lists, sets, and hashes. Its in-memory architecture ensures high performance, making it an ideal choice for caching and session management in modern applications.

The spring-boot-starter-redis is a Spring Boot starter that simplifies integrating Redis into Spring applications. It includes all the necessary dependencies to connect, configure, and operate with Redis.

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Use our Online Code Editor

Spring Boot provides the spring-boot-starter-redis starter, enabling seamless communication with the Redis server. It includes various components that facilitate efficient interaction with Redis.

JedisConnectionFactory: Manages and establishes the connection between the Spring Boot application and the Redis server.
RedisTemplate: It provides methods to perform operations like saving, retrieving, and deleting data in Redis.
StringRedisTemplate: A specialized version of RedisTemplate that simplifies operations for String-based keys and values.
OpsForValue: Supports operations on simple key-value pairs in Redis.
OpsForHash: It is providing methods to perform operations based on the Hash Data structure.
OpsForList: Provides methods to interact with Redis Lists.
OpsForSet: Facilitates operations on Redis Sets.

Spring Boot with Redis Integration

Spring Boot provides seamless integration with Redis, an in-memory data store, through the spring-boot-starter-redis starter. It simplifies configuration and enables developers to use Redis for caching, messaging, and data persistence.

Prerequisites for Running the Spring Boot Redis Integration Project

Redis Server (Local or Cloud-based; here we use Docker)
Java Development Kit (JDK 17 or above)
Maven (Build tool)
IDE (e.g., IntelliJ IDEA, Eclipse, or Spring Tool Suite)
Postman (Optional, for testing REST APIs)
Project Build Using Maven

Docker Redis Setup

In this article, we install Redis using Docker. We can also manually download it from the Redis website, but here, we download the latest Redis image from Docker Hub (ensure Docker is already installed on your machine).

We have a sample Spring Boot application that you can clone from GitHub for initial setup. The initial code is available in the main branch, so please check out the main or redis integration branch. I also added the Postman collection to the root directory of the project so you can test all the API before integration.

Steps to Integrate Redis with Spring Boot

Add the Maven dependency in the pom.xml file. Since we are using Docker, we also include the Docker Compose dependency.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-docker-compose</artifactId>
    <scope>runtime</scope>
</dependency>

Use our Online Code Editor

Configure Redis Connection or database connection (we’re using H2 as database). Add the Redis server configuration to application.properties or application.yml

spring.application.name=spring-boot-redis-cache

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

spring.cache.type=redis
spring.data.redis.host=localhost
spring.data.redis.port=6379

# if we are using local redis or cloud but here we use docker so there is no need of username or password
spring.data.redis.username=
spring.data.redis.password=

Use our Online Code Editor

Create the docker-compose.yml file in the root folder with the same naming convention we follow for docker-redis configurations.

services:
  redis:
    image: redis:7.4.2
    ports:
      - 6379:6379

Use our Online Code Editor

Mark the Spring Boot application class as @EnableCaching to enable caching in our Spring Boot application. To enable caching in our Spring Boot application, add the @EnableCaching annotation to one of our configuration classes. This annotation triggers a post-processor that inspects each Spring bean for caching annotations.

package com.ayshriv.springbootrediscache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class SpringBootRedisCacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootRedisCacheApplication.class, args);
    }

}

Use our Online Code Editor

Create the class RedisConfig.class inside the config package

package com.ayshriv.springbootrediscache.config;

import com.techie.springbootrediscache.dto.ProductDto;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;

@Configuration  // Marks this class as a Spring configuration class
public class RedisConfig {

    @Bean  // Defines a Spring bean for RedisCacheManager
    public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        // Define cache configuration
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(10)) // Set time-to-live (TTL) for cache entries to 10 minutes
                .disableCachingNullValues() // Prevent caching of null values
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(new Jackson2JsonRedisSerializer<>(ProductDto.class))); // Serialize values using Jackson JSON serializer

        // Create and return a RedisCacheManager with the specified configuration
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfig) // Apply default cache configuration
                .build();
    }
}

Use our Online Code Editor

This class configures Redis caching in a Spring Boot application. The @Configuration annotation marks it as a configuration class, and the @Bean annotation defines a RedisCacheManager bean.

The cache configuration includes a time-to-live (TTL) of 10 minutes (Duration.ofMinutes(10)), which ensures that cached data expires automatically after this period. It also disables the caching of null values (disableCachingNullValues()) to optimize memory usage.

For serialization, the Jackson2JsonRedisSerializer is used, which converts Java objects (ProductDto) to JSON before storing them in Redis. This ensures that cached data remains structured and readable.

The RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(cacheConfig).build() the method initializes the cache manager with the given configuration and connects it to the Redis database using RedisConnectionFactory.

After doing all the configurations, we implement the caching on the business class (service class).

package com.ayshriv.springbootrediscache.service;

import com.techie.springbootrediscache.dto.ProductDto;
import com.techie.springbootrediscache.entity.Product;
import com.techie.springbootrediscache.repository.ProductRepository;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    private final ProductRepository productRepository;

    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    @CachePut(value="PRODUCT_CACHE", key="#result.id")
    public ProductDto createProduct(ProductDto productDto) {
        var product = new Product();
        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product savedProduct = productRepository.save(product);
        return new ProductDto(savedProduct.getId(), savedProduct.getName(),
                savedProduct.getPrice());
    }

    @Cacheable(value="PRODUCT_CACHE", key="#productId")
    public ProductDto getProduct(Long productId) {
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new IllegalArgumentException("Cannot find product with id " + productId));
        return new ProductDto(product.getId(), product.getName(),
                product.getPrice());
    }

    @CachePut(value="PRODUCT_CACHE", key="#result.id")
    public ProductDto updateProduct(ProductDto productDto) {
        Long productId = productDto.id();
        Product product = productRepository.findById(productId)
                .orElseThrow(() -> new IllegalArgumentException("Cannot find product with id " + productId));

        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product updatedProduct = productRepository.save(product);
        return new ProductDto(updatedProduct.getId(), updatedProduct.getName(),
                updatedProduct.getPrice());
    }

    @CacheEvict(value="PRODUCT_CACHE", key="#productId")
    public void deleteProduct(Long productId) {
        productRepository.deleteById(productId);
    }
}

Use our Online Code Editor

When we mark the createProduct() method with this @CachePut(value = "PRODUCT_CACHE", key = "#result.id") annotation, this ensures that the object returned by this method is stored or updated in the cache named PRODUCT_CACHE, and the key part specifies that the cache key should be the ID of the returned ProductDto object.

This is useful in scenarios where a new product is created or an existing product is updated, as it ensures that the latest product details are stored in the cache. By using this annotation, subsequent requests for the same product can be served quickly from the cache, reducing database queries and improving application performance while keeping the cache up to date.

Next, when we mark the getProductById() method with this @Cacheable(value = "PRODUCT_CACHE", key = "#productId") annotation, this ensures that the returned object by this method is stored in the cache named "PRODUCT_CACHE", and the key The part specifies that the cache key should be the productId parameter passed to the method.

If the requested productId is already present in the cache, the method skips execution and directly returns the cached value, avoiding a database call. However, if the productId is not found in the cache, the method executes, retrieves the product from the database, stores the result in the cache, and then returns it.

When we mark the deleteProduct() method with this @CacheEvict(value = "PRODUCT_CACHE", key = "#productId") annotation, this ensures that the cache entry associated with the given productId is removed from the cache named "PRODUCT_CACHE". The key part specifies that the cache key to be evicted is the productId parameter passed to the method.

This means that after deleting a product from the database, its cached entry will also be removed, ensuring that stale data is not served from the cache in future requests. If the deleted product is requested again, it will be fetched from the database and re-cached if applicable.

Here, we do all the things with the help of the annotation-based approach, but we can also do the same things with the help of CacheManager

The CacheManager It is a Spring framework interface responsible for managing different cache implementations. It acts as a central mechanism to store, retrieve, and manage cached data efficiently..

private final CacheManager cacheManager;

public ProductDto createProduct(ProductDto productDto) {
        var product = new Product();
        product.setName(productDto.name());
        product.setPrice(productDto.price());

        Product savedProduct = productRepository.save(product);
        Cache productCache = cacheManager.getCache("PRODUCT_CACHE");
        productCache.put(savedProduct.getId(), savedProduct);

        return new ProductDto(savedProduct.getId(), savedProduct.getName(),
                savedProduct.getPrice());
    }

Use our Online Code Editor

Test the application

ADD-PRODUCT: http://localhost:8080/api/product

2. GET-PRODUCT: http://localhost:8080/api/product/3

3. UPDATE PRODUCT: http://localhost:8080/api/product

4. DELETE PRODUCT: http://localhost:8080/api/product/2

Conclusion

Redis with Spring Boot makes apps faster by caching data and reducing database calls. Using @Cacheable, @CachePut, and @CacheEvict, We can easily store, update, and delete cached data. This improves speed, reduces server load, and helps the app handle more users smoothly.

When we are performing the create operation, the response of this operation is stored in the cache, so whenever we perform operations like the getProduct() It checks the product in the cache first; if the product is present inside the cache, it returns that; if not, then it will return from the database.

Similarly, when we perform the delete operation, first it deletes the data from the database and then deletes it from the cache as well. All these types of operations reduce the number of DB calls so the performance of the application is increased.

Have a great one!!!

Author: Ayush Shrivastava

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

How to Become a Backend Developer (2026)

Jane — Wed, 18 Mar 2026 10:30:00 +0000

The world of backend development can feel overwhelming at first, especially if you're just starting. However, you're in the right place if you’re a newbie or someone curious about backend development. In this guide, we will break down everything you need to know to become a backend developer in 2025, step by step.

We will explore the core concepts of backend development, the technologies you’ll need to learn, and the pathways to becoming a proficient backend developer. By the end of this guide, you’ll have a clear roadmap for your journey.

What is Backend Development?

Backend development refers to the server-side of web applications. It’s everything that happens behind the scenes that users don’t see, but is crucial to make the app work. As a backend developer, you will deal with databases, server management, APIs, and the business logic that powers the app.

To help you visualize, let’s break down the core components of a backend application:

Server: The physical or virtual machine that hosts the web application.
Database: The storage system where the application data is stored, such as MySQL, MongoDB, or PostgreSQL.
Application: The code that runs the logic of the app. It handles the requests made by users and fetches the data from the database.
APIs (Application Programming Interfaces): These allow different systems to communicate with each other. Backend developers often create and manage APIs.

Here’s a structured backend development content hub that will guide you step-by-step to become a great backend engineer.

Steps to Becoming a Backend Developer

Below are the steps to become a backend developer. We have included course recommendations are the latter part of this guide to help you get started immediately.

1. Learn the Fundamentals of Programming

As with any programming role, learning the fundamentals of coding is crucial. Before jumping into backend-specific technologies, you should have a strong understanding of the following core concepts:

Variables and Data Types
Control Structures (if statements, loops)
Functions and Methods
Object-Oriented Programming (OOP)

Programming languages that are commonly used in backend development include Python, Java, JavaScript (Node.js), Ruby, PHP, and Go. If you're just starting out, we recommend Python for its readability and versatility, which makes it a popular choice for beginners.

2. Choose a Backend Language

Once you're comfortable with the basics of programming, it’s time to pick a backend language. Each backend language has its strengths and is suited for different types of applications.

Recommended Backend Languages:

Python: A great starting language due to its simplicity and wide usage in backend frameworks like Django and Flask.
JavaScript (Node.js): If you already know JavaScript from frontend development, learning Node.js will allow you to use the same language on both the frontend and backend.
Java: Known for its stability and scalability, Java is used for large enterprise-level applications and backend systems.
Ruby: Ruby on Rails is a popular framework for building web applications quickly.
Go (Golang): A systems programming language designed by Google, Go is known for its speed and efficiency, making it ideal for high-performance applications.

For someone starting, we would recommend starting with Python or JavaScript (Node.js), as both have extensive resources and beginner-friendly frameworks.

At Masteringbackend, we have a series of courses on Python, Node.js, Rust, Ruby, PHP, and Golang created following industry-standard roadmaps to turn you into a great backend engineer.

3. Learn about Databases

Backend development involves dealing with data, so understanding how databases work is crucial. There are two primary types of databases you'll encounter in backend development:

Relational Databases (SQL): These databases store data in tables and use SQL (Structured Query Language) to interact with the data. Popular examples include MySQL, PostgreSQL, and SQLite.
Non-relational Databases (NoSQL): These databases are more flexible and store data in formats like JSON or key-value pairs. Examples include MongoDB, Redis, and Cassandra.

Learning SQL is essential for any backend developer, as it’s used to query relational databases. But understanding NoSQL databases is equally important, especially as the web becomes more data-driven.

When to Use SQL vs. NoSQL:

Get acquainted with databases and how they help store, retrieve, and manipulate data.

4. Understand How the Web Works

As a backend developer, you’ll need to understand how the web works at a fundamental level. This includes learning about HTTP (Hypertext Transfer Protocol), the protocol that powers web communication. Here are a few key concepts to master:

HTTP Methods: GET, POST, PUT, DELETE, and PATCH.
Request and Response: How clients (e.g., web browsers) send requests to the server, and how the server responds.
Status Codes: What different HTTP status codes (like 200, 404, 500) mean and how to handle them.
RESTful APIs: Learn how REST (Representational State Transfer) works to create standardized APIs that allow different systems to communicate.

Understanding the flow of information from the client to the server is essential in backend development.

Here's a diagram that illustrates how various components interact in a backend system:

5. Master a Backend Framework

Once you’ve chosen your backend language and learned the basics, it’s time to dive into frameworks. Frameworks make backend development easier by providing tools and libraries that handle common tasks.

Popular Backend Frameworks:

Python: Django, Flask
JavaScript (Node.js): Express.js, Koa.js
Java: Spring Boot, Java EE
Ruby: Ruby on Rails

Each of these frameworks has its own strengths, but Django (Python) and Express (Node.js) are excellent choices for beginners. They both have large communities and extensive documentation, making it easier to get started.

6. Learn About APIs and Web Services

As a backend developer, you’ll often need to create and manage APIs (Application Programming Interfaces). APIs allow the backend to communicate with the frontend, third-party services, and external systems. Understanding how to build, test, and consume APIs is a crucial skill.

A commonly used architectural style for APIs is REST (Representational State Transfer), but you may also encounter GraphQL or gRPC.

Building a RESTful API:

Use appropriate HTTP methods (GET, POST, PUT, DELETE)
Ensure the API is stateless
Design meaningful resource names and use proper HTTP status codes

API and API design is a broad topic and one that is necessary for every backend engineer. We have covered API and API design in our newsletter series here.

7. Version Control with Git

Version control is an essential skill for any developer. Git helps you track changes in your code, collaborate with other developers, and deploy your code to production.

Learn how to use Git for managing your code and collaborating with other developers on platforms like GitHub or GitLab. Mastering Git is a must-have skill for backend developers.

Branching, Pull Requests, and Merge Conflicts:

Learn how to create feature branches and submit pull requests.
Understand how to resolve merge conflicts to maintain a clean codebase.

8. Testing and Debugging

Testing is a vital part of backend development. It ensures that the application behaves as expected and helps catch bugs early in development. Learn how to write unit tests, integration tests, and use debugging tools to troubleshoot issues in your backend code.

Types of Testing:

Unit Testing: Testing individual components in isolation.
Integration Testing: Testing how different components work together.
End-to-End Testing: Testing the entire flow of an application.

Testing Tools:

Jest (for Node.js)
PyTest (for Python)
JUnit (for Java)

9. Deploying Applications

Once you’ve built a backend application, you need to deploy it. Learning how to deploy your backend code to a server is a critical step in the development process. Popular deployment platforms include:

Heroku
AWS (Amazon Web Services)
Google Cloud Platform
Microsoft Azure

Learn how to deploy your backend applications to one of these platforms and understand the basics of CI/CD (Continuous Integration and Continuous Deployment).

CI/CD and Docker

Modern backend development requires not only deploying your applications but also setting up CI/CD pipelines to automate testing and deployment. Docker is a popular tool for containerizing applications, and Kubernetes helps with managing these containers in a scalable way.

10. Build Projects

The best way to cement your knowledge is by building projects. Here are some project ideas to get started:

Build a simple CRUD application (Create, Read, Update, Delete) using a backend framework and database.
Create a blog API that allows users to create and manage blog posts.
Build an e-commerce API for managing products, orders, and users.

You can explore a list of 100+ backend projects you can start building now.

Conclusion

Becoming a backend developer takes time, practice, and a commitment to learning. By following the steps outlined in this guide, starting with the basics, learning key technologies, and building projects, you’ll be well on your way to becoming a skilled backend developer.

If you’re looking for structured courses that will guide you step-by-step, check out MasteringBackend.com for a variety of backend-focused courses designed to take you from beginner to pro.

Remember, the journey to becoming a backend developer is all about consistency. Stay curious, keep building, and you’ll be creating powerful server-side applications in no time.

Have a great one!!!

Author: Solomon Eseme

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Spring Boot + Docker: Dockerizing Java Spring Boot Apps

Jane — Tue, 17 Mar 2026 10:30:00 +0000

Docker has changed the way we build, run, and scale applications.

It lets you package your app with everything it needs, so it runs the same everywhere, on your computer, on someone else’s, or on a server.

Docker is one of the most popular tools for this. It helps keep things consistent and avoids the “it works on my machine” problem.

In this blog, we will see how to containerize a Spring Boot application using Docker, step by step. By the end, you’ll be able to run your Spring Boot app inside a Docker container and deploy it seamlessly.

What is Docker?

Docker gets its name from the term "dock worker," someone who loads and unloads shipping containers. Similarly, Docker "loads" and "runs" software containers.
Using docker we can implement the containerization technologies.
Containerization is a concept that allows us to package software applications along with the necessary libraries and binaries required to run them. This package is called an image.
Docker is tool/platform that makes it easy to create, manage or run the containers.

Click here to read the definitive guide to Docker.

Why Docker?

Suppose we're building a Spring Boot application on our local machine. It runs perfectly because our system has the correct versions of Java, Maven, and other necessary tools installed. However, when we want to deploy this application to another machine, we have to manually set up all the required software.

In real-world projects, applications are typically deployed to multiple environments for testing and production, such as DEV, UAT, SIT, and PROD.

Ensuring that each of these environments has the exact setup can be a time-consuming and error-prone process. One machine might have a different Java version or might be missing certain dependencies, leading to unexpected errors.

Now, if we use Docker, we can create a Dockerfile that includes our application, the exact Java version, and all required settings. Once packaged into a Docker image, the application can run on any system with Docker installed, without worrying about environment-specific configurations. We can run the same container across all environments just as we do locally.

This consistency not only saves time but also greatly simplifies both development and deployment.

Prerequisites

To follow along, ensure you have:

Basic knowledge of Java, Spring Boot, and Maven
Installed:
- Java
- Maven
- Docker & Docker CLI
- An IDE (e.g., IntelliJ, VS Code)

Simple Spring Boot Application

We’ll use a simple Spring Boot project with just one REST API that returns "Hello, World!" when the /hello endpoint is accessed. We’ve pushed the code to GitHub, so you can simply clone the repository and switch to the master branch.

You can check out the full code here:

https://github.com/ayushstwt/docker-spring-boot

Test Spring Boot Application on localhost

http://localhost:8080/hello

Docker Terminology

Docker file- It contains set of instructions to build docker image.
Docker Image- It is a package which contains application code + dependencies.
Docker Hub- It is a registry to store docker images. (AWS ECR)
Docker Container- It is a runtime instance of our application Run time instance of an image. If you run docker image container will be created that's where our application is running.

To Generate docker image from our spring-boot application there are three different commonly used approaches. we can choose one of theme.

Dockerfile
Buildpacks
Google Jib

Approach 1

Running a Spring Boot application as a container using Dockerfile

Step 1 - Run the maven command, “mvn clean install”. to generate a fat jar inside the target folder.

Step 2- Create the file name as Dockerfile inside the root directory to generate a Docker image.

FROM openjdk:17-jdk-slim
COPY target/docker-spring-boot-0.0.1-SNAPSHOT.jar docker-spring-boot-0.0.1-SNAPSHOT.jar
ENTRYPOINT ["java","-jar","/docker-spring-boot-0.0.1-SNAPSHOT.jar"]

Use our Online Code Editor

Here in the above file

FROM openjdk:17-jdk-slim – Uses a lightweight OpenJDK 17 base image to run the Spring Boot application. COPY target/docker-spring-boot-0.0.1-SNAPSHOT.jar docker-spring-boot-0.0.1-SNAPSHOT.jar – Copies the built JAR file from the target directory into the Docker image. ENTRYPOINT ["java","-jar","/docker-spring-boot-0.0.1-SNAPSHOT.jar"] – Defines the command to run the Spring Boot JAR when the container starts.

To use Docker, first download Docker Desktop from docker.com/products/docker-desktop. Pick the version for your OS (Windows or macOS). If you're on Linux, follow the guide at docs.docker.com/engine/install. Install it like any app and launch Docker Desktop.

Next, open your terminal and run docker login. Enter your Docker Hub username and password. If you don’t have an account, create one at hub.docker.com/signup.

Once logged in, you’re ready to build images, run containers, and manage apps easily.

Step 3 - Execute the docker command to generate the docker image based on the tag name. make sure that your docker desktop is running.


// syntax
docker build -t your-image-name:tag .

// command
docker build -t ayshriv/docker-spring-boot:latest .

Use our Online Code Editor

After executing this command, you’ll see an output indicating that the Docker image was successfully generated. The docker build command is used to create a Docker image from a Dockerfile. The -t flag allows you to specify a name for your image and optionally assign a version tag.

For example, in docker-spring-boot:latest, docker-spring-boot is the image name and latest is the tag. The . (dot) at the end tells Docker to use the current directory as the build context, where it looks for the Dockerfile and all necessary files.

To verify that the image was successfully created, use the docker images command. This will list all the Docker images available on your system.

Step 4 - Next, execute the following command to create and run a Docker container based on the image you just built.

docker run -p 8080:8080 ayshriv/docker-spring-boot:latest

Use our Online Code Editor

The command docker run -p 8080:8080 ayshriv/docker-spring-boot:latest is used to start a Docker container from the image we built. The -p 8080:8080 option maps port 8080 on your host machine to port 8080 inside the container, allowing you to access the application via http://localhost:8080.

Here, ayshriv/docker-spring-boot:latest is the name and tag of the Docker image. This command runs your Spring Boot application inside a container, exactly as it would run in production.

In the 8080:8080 format:

The first value (host port) is the external port on your machine.
The second value (container port) is the internal port your app listens on inside the container.

After executing this command, you should see output indicating that the container is running successfully.

To check if your container is running, use the docker ps command. This will display a list of all currently running containers.

The Docker image name ayshriv/docker-spring-boot:latest, ayshriv is your Docker Hub username, which helps identify you as the owner of the image. docker-spring-boot is the name of your application, and it's good practice to keep this name short, clear, and related to what your app does.

The part after the colon, latest, is the tag, which usually refers to the current or most recent version of the image. You can also use tags like v1.0, prod, or dev to manage different versions.

While creating a Docker image using a Dockerfile is effective and widely adopted, it does have some drawbacks. One major issue is the size of the resulting image, which can be quite large—especially when using base images like OpenJDK. Larger images take more time to build, transfer, and start, which can negatively impact development speed and deployment efficiency.

Additionally, maintaining a Dockerfile requires ongoing effort, as you'll need to update it whenever your application's structure or dependencies change. In our case, the generated image size is around 428MB, which is quite substantial.

The next approach we'll explore helps reduce image size and requires minimal manual effort.

Approach 2

Running a Spring Boot application as a container using Buildpacks

Cloud Native Buildpacks transform your application source code into images that can run on any cloud. It is an alternative approach to dockerfiles. With the help of Buildpacks we can automatically generate production ready images form our application source code without writing the Dockerfile.

https://buildpacks.io/

Step 1- We need to add the given configuration inside the pom.xml for the image name.

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                            <name>ayshriv/${project.artifactId}:latest</name>
                    </image>
                </configuration>
            </plugin>
        </plugins>
  </build>

Use our Online Code Editor

Here, also we follows the same naming convention for image name.

Step 2- Now, we run the given maven command to generate the docker image with out the need of Dockerfile (make sure that docker desktop is running).

mvn spring-boot:build-image

Use our Online Code Editor

Step 3 – Next, execute the following command to create a Docker container from the image, along with the required port mapping.

docker run -p 8080:8080 ayshriv/docker-spring-boot:latest

Use our Online Code Editor

With this approach, there’s no need to create a Dockerfile manually, and the resulting image size is also reduced. However, one limitation is that Docker Desktop still needs to be installed on your local machine to build and run the image.

To overcome this dependency, we can use Google JIB, a tool specifically designed for Java applications. JIB allows you to generate a Docker image for your Spring Boot application without needing a Dockerfile or Docker installed locally, while also producing smaller and more optimized images.

Approach 3

Running a Spring Boot application as a container using Google JIB

https://github.com/GoogleContainerTools/jib

Google JIB is used to Build container images for your Java applications, without need of Dockerfile and Docker Desktop. it is an alternative approach to dockerfiles. With the help of Google JIB we can automatically generate production ready images form our application source code without writing the Dockerfile.

Step 1- we need to add the given configuration inside the pom.xml for the image name.

<build>
  <plugins>
    <plugin>
      <groupId>com.google.cloud.tools</groupId>
      <artifactId>jib-maven-plugin</artifactId>
      <version>3.4.0</version> 
      <configuration>
        <to>
          <image>ayshriv/${project.artifactId}:latest</image>
        </to>
      </configuration>
    </plugin>
  </plugins>
</build>

Use our Online Code Editor

Step 2- Run the given maven command to generate the docker image (for Google JIB there is no need of Docker Desktop to be installed on your local system).

mvn compile jib:dockerBuild

Use our Online Code Editor

Step 3 – After this, execute the following command to create and run a Docker container based on the image, with the appropriate port mapping.

docker run -p 8080:8080 ayshriv/docker-spring-boot:latest

Use our Online Code Editor

In this approach, we eliminate the need for a Dockerfile, and the resulting image size is significantly reduced. However, one limitation is that Docker Desktop must be installed on the local system to build and run Docker images. To overcome this dependency, we can use Google JIB, a powerful tool specifically designed for Java applications.

Google JIB allows us to containerize our Spring Boot application without writing a Dockerfile or having Docker installed locally. It integrates directly with Maven or Gradle, enabling seamless image creation and pushing to container registries. Additionally, JIB optimizes image layering, which helps in reducing image size and speeding up rebuild times during development.

Some Commonly Used Docker Commands for Java Developers

# 1. Build Docker image from Dockerfile (usually for Spring Boot app)
docker build -t my-java-app .

# 2. List all images
docker images

# 3. Run the Docker container from the built image
docker run -d -p 8080:8080 --name java-app-container my-java-app

# 4. View running containers
docker ps

# 5. View all containers (including stopped ones)
docker ps -a

# 6. Stop a running container
docker stop java-app-container

# 7. Start a stopped container
docker start java-app-container

# 8. Restart a container
docker restart java-app-container

# 9. Remove a container
docker rm java-app-container

# 10. Remove an image
docker rmi my-java-app

# 11. View logs of a container (helpful for debugging)
docker logs java-app-container

# 12. Execute a command inside a running container (like inspecting files, checking logs)
docker exec -it java-app-container bash

# 13. Tag an image (e.g., for pushing to Docker Hub)
docker tag my-java-app ayushshrivastaav/my-java-app:latest

# 14. Login to Docker Hub
docker login

# 15. Push image to Docker Hub
docker push ayushshrivastaav/my-java-app:latest

# 16. Pull image from Docker Hub
docker pull ayushshrivastaav/my-java-app:latest

# 17. Remove all stopped containers
docker container prune -f

# 18. Remove all unused images
docker image prune -a -f

# 19. Check Docker version
docker version

# 20. View system-wide Docker resource usage
docker system df

# 21. Compose up (if using docker-compose.yml for multi-container apps)
docker-compose up -d

# 22. Compose down
docker-compose down

Have a great one!!!

Author: Ayush Shrivastava

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

How to use the Default Trait in Rust

Jane — Mon, 16 Mar 2026 10:30:00 +0000

Introduction

When working with structs or enums in Rust, we often need a way to create a "standard" or "initial" instance without specifying all the fields every time. Manually setting each field can be repetitive, especially for complex types. How can we create a sensible default instance of a type conveniently?

Enter the std::default::Default trait. This trait provides a standardized way for types to offer a default value. If a type implements Default, we can easily get a default instance, simplifying initialization and making our code cleaner, particularly when dealing with configuration structs or optional fields.

The Need for Default Values

Imagine a configuration struct for an application:

struct AppConfig {
    timeout_ms: u32,
    retries: u8,
    api_endpoint: String,
    enable_logging: bool,
}

fn main() {
    // Manually creating an instance feels verbose
    let config = AppConfig {
        timeout_ms: 5000,
        retries: 3,
        api_endpoint: "https://api.example.com".to_string(),
        enable_logging: false,
    };
    // ... use config ...
}

Use our Online Code Editor

If we often need a configuration with standard settings (say, a timeout of 5000ms, 3 retries, a default endpoint, and logging disabled), writing this out repeatedly is tedious. Furthermore, if we add new fields to AppConfig, we have to update every place where we manually create it.

This is where the Default trait shines.

Introducing `std::default::Default`

The Default trait is remarkably simple. It's defined in the standard library (std::default::Default) and requires implementing just one method:

pub trait Default: Sized {
    fn default() -> Self;
}

Use our Online Code Editor

The default() associated function takes no arguments and returns an instance of the type (Self) populated with default values. Many primitive types and standard library types already implement Default (e.g., numbers default to 0, bool to false, Option to None, String and Vec to empty ones).

Implementing `Default`

There are two main ways to make our types implement Default:

Using #[derive(Default)]

If all the fields within our struct also implement Default, we can simply ask the compiler to generate the implementation for us using the derive attribute:

#[derive(Default, Debug)] // We derive Default here!
struct AppConfig {
    timeout_ms: u32,       // u32 implements Default (defaults to 0)
    retries: u8,           // u8 implements Default (defaults to 0)
    api_endpoint: String,  // String implements Default (defaults to "")
    enable_logging: bool,  // bool implements Default (defaults to false)
}

fn main() {
    let default_config: AppConfig = AppConfig::default();
    println!("Default Config: {:?}", default_config);
    // Output: Default Config: AppConfig { timeout_ms: 0, retries: 0, api_endpoint: "", enable_logging: false }
}

Use our Online Code Editor

This is the easiest way, but the derived defaults might not always be what we consider "sensible" (like 0 for timeout_ms).

For enums, we can also derive Default, but we must explicitly mark one of the unit variants (a variant without data) with #[default] to tell the compiler which one is the default:

#[derive(Default, Debug)]
enum LogLevel {
    Debug,
    Info,
    #[default] // Warning is the default level
    Warning,
    Error,
}

fn main() {
    let level: LogLevel = LogLevel::default();
    println!("Default log level: {:?}", level);
    // Output: Default log level: Warning
}

Use our Online Code Editor

Manual Implementation

If derive isn't suitable (e.g., some fields don't implement Default, or we need specific default values different from the derived ones), we can implement the trait manually:

#[derive(Debug)] // Cannot derive Default if we implement manually
struct AppConfig {
    timeout_ms: u32,
    retries: u8,
    api_endpoint: String,
    enable_logging: bool,
}

// Manual implementation
impl Default for AppConfig {
    fn default() -> Self {
        AppConfig {
            timeout_ms: 5000, // Sensible default timeout
            retries: 3,       // Sensible default retries
            api_endpoint: "https://api.example.com".to_string(), // Default endpoint
            enable_logging: false, // Logging off by default
        }
    }
}

fn main() {
    let sensible_defaults: AppConfig = AppConfig::default();
    println!("Sensible Defaults: {:?}", sensible_defaults);
    // Output: Sensible Defaults: AppConfig { timeout_ms: 5000, retries: 3, api_endpoint: "https://api.example.com", enable_logging: false }
}

Use our Online Code Editor

Here, we provide the exact default values we want inside the default() function. Remember, we cannot both derive and manually implement Default for the same type.

Using Default

Once a type implements Default, we can get its default value using TypeName::default() or the fully qualified path std::default::Default::default().

A particularly useful pattern is combining Default::default() with struct update syntax. This lets us specify only the fields we want to change, while the rest take their default values:

#[derive(Default, Debug)]
struct AppConfig {
    timeout_ms: u32,
    retries: u8,
    api_endpoint: String,
    enable_logging: bool,
}

impl AppConfig {
 fn default() -> Self { // Custom sensible defaults
        AppConfig {
            timeout_ms: 5000,
            retries: 3,
            api_endpoint: "https://api.example.com".to_string(),
            enable_logging: false,
        }
    }
}


fn main() {
    // Override only timeout and logging, keep other defaults
    let custom_config = AppConfig {
        timeout_ms: 10000,
        enable_logging: true,
        ..AppConfig::default() // Fill the rest with defaults
    };

    println!("Custom Config: {:?}", custom_config);
    // Output: Custom Config: AppConfig { timeout_ms: 10000, retries: 3, api_endpoint: "https://api.example.com", enable_logging: true }
}

Use our Online Code Editor

This makes creating slightly modified instances very easy.

Common Use Cases

Configuration Structs: Providing sensible defaults for application settings.
Builder Pattern: Often, the Default implementation provides the starting point for a builder.
Initializing Collections: Getting an empty Vec, HashMap, or String.
Generic Code: In generic functions, T: Default allows creating a default instance of T.
Testing: Quickly creating instances with default data for tests.

Considerations

Derive Limitations: #[derive(Default)] only works if all fields implement Default. If even one field doesn't, we must implement it manually.
Meaningful Defaults: Ensure the default values make sense for the type's purpose. Sometimes the derived defaults (like 0 or empty strings) aren't appropriate.
Initialization Cost: While usually cheap, the default() function can perform non-trivial work (like allocating memory for a String or Vec, or even more complex setup). Be aware if performance in initialization is critical.

Summary

The std::default::Default trait provides a clean and standard way to create default instances of Rust types. Whether through the convenient #[derive(Default)] attribute or a manual implementation for more control, it helps reduce boilerplate code and makes initializing structs and enums more ergonomic.

With Default::default() and struct update syntax, we can create instances with little fuss, focusing only on the values that differ from the standard defaults. If you want to learn more about rust you can always check out our in-depth course on the language

Have a great one!!!

Author: Ugochukwu Chizaram

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Top 5 Backend Development YouTube Channels

Jane — Fri, 13 Mar 2026 10:30:00 +0000

YouTube has become a safe haven for backend developers. This is because it contains both short-form and long-form videos on a variety of topics on backend development. It is also a preferred medium because it is easier for learners to follow how a task is carried out in visual detail, an easier way to learn for some than reading a book.

In this article, we take a dive into the top 5 YouTube channels catering to the improvement of backend developers. These channels have earned their place because they make difficult concepts easier to understand, and in some cases provide humorous takes and perspectives on the industry. Without further ado, let’s check them out.

Hussein Nasser

Hussein Nasser has dedicated his channel to discussing databases, backend architecture, APIs, caching, latency and production-level thinking and designs. His channel is one of the most backend-focused channels on the platform and is a must-see for learners of backend concepts and practical advice for better backend development.

Fireship

While fireship may not be considered purely backend in its focus, the channel is backend-heavy. Fireship brings in humor and sarcasm to his explanations, making them relatable and just genuinely fun. He provides quick context before going in-depth into a topic, catering to both the needs of those who simply want a topic overview and those who want to dive right in.

ByteByteGo

ByteByteGo places a heavy priority on system design. He’s great at explaining distributed systems, system design fundamentals, databases and scalability concepts. The videos are visual and concise. It is an important channel for backend developers as backend development is deeply concerned with thinking in systems, not simply writing endpoints that run.

freeCodeCamp

freeCodeCamp has won a reputation in the software development community as being one of the largest and most reliable sources of long-form backend education. The channel is great at microservices, databases and authentication. It also provides complete backend courses in a variety of languages like Java, Go, Python and Node (JS/TS).

Traversy Media

Traversy Media provides highly practical advice and backend education. There are in-depth explanations on Rest APIs, authentication workflows, Node.js, Express and databases. He walks through real projects and provides clear explanations.

These channels are great and noteworthy. However, there are several backend development channels on YouTube that are equally amazing you could checkout. Some of them are TechWorld with Nana, Programming with Mosh, ThePrimeagen and our very own Mastering Backend YouTube channel. While some channels are not explicitly backend focused, they still provide valuable insights that would take your backend development career to the next level.

Have a great one!!!

Author: Amanda Ene Adoyi

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Structuring AI Microservices in Python

Jane — Thu, 12 Mar 2026 10:30:00 +0000

Being able to structure AI microservices in Python and learning how to split AI workloads into clean, independent services, while also having an idea on how to design Python APIs for model inference the right way, helps to avoid some common mistakes that can hurt performance and scalability.

One of the main reasons why tools like FastAPI and Docker fit into real-world AI systems. Probably you’re just getting started, or you're refining production systems. This walkthrough helps you build AI microservices that are easier to maintain, scale, and ship with confidence.

From folder structure to deployment basics, the reasons why each boundary exists. These choices directly affect scalability, deployment speed, and system reliability. This guide focuses on practical decisions that help your AI services stay reliable as they grow.

Folder Structure for a Production AI Microservice

Having a clean folder structure is the foundation of a production-ready AI microservice. It determines how fast you can ship features, debug issues, and scale the system as models evolve. You want separation by responsibility and not by convenience.

Some common mistakes people tend to make are dumping model logic, API routes, and infrastructure code into the same folder. It works early at times, but eventually it breaks quickly in production.

A practical, production-grade structure looks like this:

app/
├── api/
│   ├── v1/
│   │   ├── routes.py
│   │   └── schemas.py
│
├── core/
│   ├── config.py
│   └── logging.py
│
├── services/
│   ├── inference_service.py
│   └── preprocessing.py
│
├── models/
│   └── model_loader.py
│
├── repositories/
│   └── data_access.py
│
├── workers/
│   └── background_tasks.py
│
├── tests/
│   └── test_api.py
│
└── main.py

Use our Online Code Editor

Each layer has a single job.

The api layer handles HTTP concerns only. Request validation, response schemas, and versioning live here.

The services layer contains AI-specific behavior like model inference, prompt handling, feature extraction, and post-processing belongs here as it keeps AI logic reusable and testable.

The models folder isolates model loading and lifecycle management. Whether the model runs locally, on a GPU, or via a remote endpoint, the API never needs to know.

The core layer centralizes configuration, environment variables, and logging. This prevents hard-coded values from leaking across the codebase.

The repositories layer abstracts databases, vector stores, or external APIs. Swapping a data source should not require touching AI or API code.

Background workloads, such as batch inference, retraining triggers, or long-running tasks, live in workers. This keeps request latency predictable under load.

This structure simply supports horizontal scaling, independent deployment, and clean ownership boundaries. More importantly, it lets you change models without rewriting the service, which is very important in real-world AI systems.

Loading Models Efficiently at Startup

Loading models the wrong way can slow startup, exhaust memory, or cause request timeouts under traffic spikes. You want models loaded once, not per request.

Some common patterns used are initializing the model inside an API handler, which forces the system to reload weights repeatedly, increasing response time and CPU usage. In production, this can turn a fast endpoint into a bottleneck.

In Python microservices, the model is created, warmed up, and stored in memory before traffic hits the service. Requests then reuse the same procedure, which gives predictable performance with the request latency dropping, which is why memory management matters.

Large models can consume lots of gigabytes of RAM or VRAM, and loading multiple copies accidentally is one of the fastest ways to crash a container. To avoid that, always try to confirm if the model is instantiated once per process. If the model is large, lazy loading can help.

What lazy loading simply means is initializing the model only when it is first needed, then caching it for future requests. This helps to reduce startup time for services that may not receive traffic immediately, and it is useful in serverless or auto-scaling environments.

After loading, you then run a small inference pass. This initializes internal kernels, caches, and memory allocations. Without a warm-up, the first real user request often experiences higher latency.

When models are external, such as hosted inference endpoints, cache the client configuration instead of rebuilding it per request. Connection pooling and persistent sessions reduce overhead and improve throughput.

Efficient startup loading leads to faster responses, fewer crashes, and smoother scaling. In production AI microservices, this is not an optimization; it is a baseline requirement.

Configuration Management for AI Services

Configuration controls how your AI service behaves across environments. You want the configuration separated from the code; poor configuration management leads to fragile deployments, hard-to-debug bugs, and unsafe production changes.

Trying to hard-code values like model paths, API keys, batch sizes, or timeout limits makes services inflexible and a single change in them requires a rebuild and redeploy, which slows teams down and increases risk.

Instead of trying to read raw environment variables everywhere, load them once into a structured config object. This allows validation at startup, and if a required value is missing or invalid, the service fails fast instead of breaking under load.

API keys, tokens, and credentials should not live in source control. Use secret managers or encrypted environment variables provided by the deployment platform to access them at startup and avoid logging them at any point.

Rather than deploying new AI behavior directly, keep it behind configuration flags. This allows controlled rollouts, quick rollbacks, and A/B testing without redeploying services and when multiple AI microservices share common settings, such as logging formats or request limits, standardizing configuration reduces drift, which also makes onboarding new services faster and more predictable.

Good configuration management turns AI services from fragile experiments into predictable systems. When configuration is clean, validated, and environment-aware, production issues become easier to detect and easier to fix.

Logging and Monitoring AI Microservices

Logging and monitoring are non-negotiable for AI microservices because without them, failures look random, and performance issues surface too late.

Which is why every request should produce structured logs that include request IDs, model name or version, inference duration, response status, and error details, as plain text logs make correlation hard, while structured logs make them searchable and machine-friendly.

AI services somehow fail differently from typical APIs. By tracking model load time, inference latency, token counts, input size, and output truncation events. These signals help to detect slow models, memory pressure, and unexpected usage patterns early.

Monitoring also helps to prevent cascading failures by tracking request rate, error rate, and latency percentiles (p50, p95, p99). For AI workloads, monitoring queue depth, concurrency levels, and resource usage often indicate model overload or inefficient batching.

When inference latency increases, upstream services feel it immediately, and the alerts based on thresholds help you react before users notice.

AI services can generate large logs under high traffic, use sampling for high-frequency events, and full logs for errors.

Effective logging and monitoring make AI microservices observable systems. When behavior is visible, issues become diagnosable, performance becomes measurable, and scaling becomes safer.

Have a great one!!!

Author: Toluwanimi Fawole

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.

Why Backend Engineers Should Learn AI

Jane — Wed, 11 Mar 2026 10:00:30 +0000

I've been thinking about this topic for a while now, and I've had enough conversations with backend engineers over the past year to finally sit down and write about it properly.

The question I keep getting is some version of this: "Should I learn AI? Is it really necessary for backend engineers, or is it just hype?"

My answer has changed over the past two years. It used to be something like "it depends on what you're building." Now, my answer is more direct: yes, you should learn AI, and the sooner you start thinking about it seriously, the better positioned you'll be for what's coming.

But let me explain what I actually mean by that, because "learn AI" can mean very different things depending on who's saying it.

The Shift That's Already Happening

If you've been paying attention to the job market, the developer tools landscape, or even just the conversations happening in engineering communities, you've probably noticed something changing.

AI is no longer a separate category of software that only specialized teams work on. It's becoming a layer that runs through almost everything. Product teams are adding AI features to existing applications. Companies are rebuilding workflows around language models. Infrastructure is being designed with AI workloads in mind from the start.

A recent analysis from PwC showed that engineers with AI skills are seeing salary increases of up to 56% compared to their peers without those skills. That's not a small difference.

And it's not because companies are paying a premium for people who understand transformer architecture, it's because they need engineers who can actually build and maintain systems that use AI reliably.

This is where backend engineers come in, and this is why I think the opportunity is particularly interesting for us.

Why Backend Engineers Specifically

Here's something I've realized through building AI-powered systems and talking to other engineers doing the same: the hard part of AI in production is not the AI itself.

Let me explain what I mean.

When you call an API like OpenAI or Anthropic, the model does its job. You send text, you get text back. The intelligence is handled. What's not handled is everything around it — the infrastructure that makes that intelligence useful, reliable, and safe in a real application.

Think about what happens when you put an AI feature into production. Suddenly, you need to answer questions like:

What happens when the API is slow or unavailable?
How do you handle it when the model returns something wrong or inappropriate?
How do you track costs when every request has a variable price based on token usage?
How do you version your prompts and roll back when something breaks?
How do you know if the system is working correctly when the outputs are non-deterministic?

These are not AI questions. These are backend engineering questions. They're about reliability, observability, error handling, cost control, and system design. The same things we've been solving for databases, caches, message queues, and external APIs for years.

The engineers who understand both sides, how AI works and how to build production infrastructure around it, are the ones companies are struggling to find right now. And that's exactly where backend engineers have an advantage, because we already have half of the equation.

What "Learning AI" Actually Means for Backend Engineers

This is where I think a lot of the advice out there gets it wrong, and it's something I've spent a lot of time thinking about.

When most people talk about learning AI, they mean learning machine learning. They point you toward courses on neural networks, linear algebra, model training, and Python notebooks. And that knowledge is valuable; there's nothing wrong with understanding how the underlying technology works.

But for most backend engineers, that's not where you should start, and honestly, it might not be where you need to go at all.

What backend engineers actually need to understand is how to build systems that use AI effectively. That's a different skill set. It's less about training models and more about integrating them. Less about mathematics and more about architecture. Less about research and more about production.

The practical skills that matter for backend engineers working with AI look something like this:

RAG systems. Retrieval-Augmented Generation is one of the most common patterns in production AI applications. It's how you make a language model useful for your specific data, like your documents, your knowledge base, and your product information.

Building RAG well requires understanding chunking strategies, embedding models, vector databases, relevance scoring, and caching. These are all backend concerns, and getting them right is what separates a demo from a product.

AI agents and tool use. Language models can now call functions, use tools, and take multi-step actions. Building agents that do this reliably requires careful design around guardrails, iteration limits, cost ceilings, and human oversight. You're essentially building a system that can execute code paths you didn't explicitly write, which creates interesting challenges around control and predictability.

Cost management. AI APIs charge per token, meaning each request incurs a variable cost. In a production system with thousands or millions of users, costs can spiral quickly if you're not paying attention. Backend engineers need to understand how to track costs per user, per feature, and per request, and how to implement controls that prevent runaway spending.

Observability and debugging. Traditional logging and monitoring don't fully capture what's happening in AI systems. When a response is wrong, you need to understand why. Is it the prompt, the retrieval, the model, or something else? Building proper observability for AI systems requires new approaches to tracing and debugging that most backend engineers haven't encountered before.

Human-in-the-loop systems. Many production AI applications route uncertain or high-stakes outputs to humans for review before taking action. Designing these systems well, deciding when to escalate, how to queue reviews, and how to feed corrections back into the system is fundamentally a backend architecture problem.

None of this requires a PhD in machine learning. It requires the same systems thinking and engineering discipline that backend engineers already apply to other problems.

The Career Argument

I want to be honest about the career implications here, because I think they're significant.

The market is shifting in a direction that's very clear. Reports from late 2025 and early 2026 consistently show that AI-related skills are becoming a baseline expectation rather than a specialized nice-to-have.

One analysis from Stackoverflow found that around 82% of developers now use AI tools for code generation alone, which means the ability to work with AI is becoming as fundamental as knowing Git or understanding HTTP.

But there's a difference between using AI tools and building AI systems. Lots of developers can use Copilot or Claude to write code faster. Fewer can design and build the infrastructure that makes AI features work reliably in production. That second skill is more valuable and more defensible.

The engineers who position themselves at that intersection, understanding both traditional backend architecture and AI integration patterns, are going to have a significant advantage. They'll be able to work on the most interesting projects, command higher salaries, and have more options when they look for new roles.

I've seen this play out already with engineers I know. The ones who started learning AI infrastructure patterns a year or two ago are now leading AI initiatives at their companies, getting pulled into high-impact projects, and fielding more recruiter interest than they can handle.

The window to get ahead of this curve is still open, but it's closing.

How to Approach This Practically

If you're convinced that learning AI is worthwhile, the question becomes how to actually do it effectively.

My recommendation is to start with the integration layer, not the model layer. Don't begin by learning how neural networks work; begin by building something that uses a language model to solve a real problem. Call the OpenAI or Anthropic API, build a simple RAG system, and create a basic agent. Get your hands dirty with the experience of making AI do something useful.

Once you have that foundation, you can go deeper into specific areas based on what you're building. If you're working on search or knowledge systems, go deeper on retrieval and embeddings. If you're working on automation, go deeper on agents and tool use. If you're working on high-stakes applications, go deeper on evaluation and human oversight.

The mistake I see a lot of engineers make is treating AI learning like traditional computer science education, starting from first principles and working up. That works for some things, but for AI integration, I think it's backwards. Start from practical problems and learn the theory as you need it.

Also, don't underestimate how much you already know. If you've built production backend systems, you already understand distributed systems, API design, database optimization, caching strategies, error handling, and observability. All of that knowledge transfers directly. You're not starting from zero; you're adding a new capability to an existing foundation.

What I'm Building

I should mention that this isn't just theoretical advice for me. I've been building AI-powered systems for a while now, and I've been thinking a lot about how to help other backend engineers make this transition.

That's why I've been working on a program specifically designed for backend engineers who want to learn AI the right way, focused on production systems, not theory. It's a 6-week intensive where you build real AI infrastructure: RAG pipelines, agents with guardrails, human-in-the-loop systems, full observability. You ship code every week and present your system at the end.

If that sounds interesting, you can join the waitlist at masteringai.dev. I'm keeping the first cohort small so I can make sure everyone gets proper attention.

But whether you join that program or learn on your own, the important thing is to start. The shift is already happening, and the engineers who adapt early will have a significant advantage.

Final Thoughts

The question isn't really whether backend engineers should learn AI. The question is how quickly you want to position yourself for where the industry is heading.

AI isn't going to replace backend engineers. But backend engineers who understand AI infrastructure are going to replace backend engineers who don't. That's not a threat, it's an opportunity, and it plays directly to the strengths we already have.

The skills that made you a good backend engineer, systems thinking, reliability engineering, performance optimization, security awareness, are exactly the skills needed to build AI systems that actually work in production. You just need to learn how to apply them to this new context.

If you've been on the fence about whether to invest time in learning AI, I hope this gives you some clarity. The opportunity is real, the skills transfer more than you might think, and the window to get ahead is still open.

Start building something. The rest will follow from there.
Have a great one!!!

Author: Solomon Eseme

Thank you for being a part of the community

Before you go:

Whenever you’re ready

There are 4 ways we can help you become a great backend engineer:

The MB Platform: Join thousands of backend engineers learning backend engineering. Build real-world backend projects, learn from expert-vetted courses and roadmaps, track your learning and set schedules, and solve backend engineering tasks, exercises, and challenges.
The MB Academy: The “MB Academy” is a 6-month intensive Advanced Backend Engineering Boot Camp to produce great backend engineers.
Join Backend Weekly: If you like posts like this, you will absolutely enjoy our exclusive weekly newsletter, sharing exclusive backend engineering resources to help you become a great Backend Engineer.
Get Backend Jobs: Find over 2,000+ Tailored International Remote Backend Jobs or Reach 50,000+ backend engineers on the #1 Backend Engineering Job Board.

Originally published at https://blog.masteringbackend.com.