DEV Community: Jane

Difference Between OpenAI API Key and Azure OpenAI API Key

Jane — Mon, 20 Apr 2026 09:00:00 +0000

Developers can access AI models using two main platforms:

OpenAI
Azure OpenAI

Both provide access to similar AI models, but the way authentication and deployment work is different.

In this article, we will understand the difference between OpenAI API keys and Azure OpenAI API keys.

OpenAI API Key

OpenAI provides direct access to AI models through its own platform.

Developers can sign up on the OpenAI website and generate an API key.

Example platform:

https://platform.openai.com

Steps to Get OpenAI API Key

Login to OpenAI platform.
Go to API Keys.
Click Create New Secret Key.

Example:

sk-xxxxxxxxxxxxxxxxxxxxxxxx

Use our Online Code Editor

This key can be used directly with OpenAI APIs.

Example endpoint:

https://api.openai.com/v1/chat/completions

Use our Online Code Editor

Azure OpenAI API Key

Azure OpenAI provides OpenAI models through Microsoft Azure infrastructure.

Instead of using OpenAI servers directly, the requests go through Azure services.

Azure OpenAI requires:

Azure resource
Model deployment
Endpoint
API key

Example API Key:

xxxxxxxxxxxxxxxxxxxxxxxx

Use our Online Code Editor

Example Endpoint:

https://openai-demo.openai.azure.com/

Use our Online Code Editor

Key Differences

OpenAI API

Hosted by OpenAI
Direct API usage
Simple setup
Single endpoint

Azure OpenAI

Hosted on Microsoft Azure
Requires resource creation
Requires model deployment
Uses Azure endpoint

When to Use OpenAI

Use OpenAI when:

You want quick setup
You are building prototypes
You want direct API access

When to Use Azure OpenAI

Use Azure OpenAI when:

You need enterprise security
You want Azure integration
Your organization already uses Azure cloud
You need regional deployment

Conclusion

Both OpenAI and Azure OpenAI provide access to powerful AI models.

OpenAI is easier for quick development, while Azure OpenAI is better suited for enterprise applications that require scalability, security, and integration with other Azure services.

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 Create an Azure OpenAI Resource and Deploy Your First Model.

Jane — Fri, 17 Apr 2026 09:00:00 +0000

Azure OpenAI allows developers to use powerful AI models such as GPT-4, GPT-4o, and GPT-3.5 directly from the Azure cloud. These models can be used to build chatbots, AI assistants, content generators, and many intelligent applications.

In this article, you will learn how to create an Azure OpenAI resource, deploy a model, and get the API key required to use the service in your application.

Prerequisites

Before starting, make sure you have:

An Azure account
Access to the Azure Portal
Azure OpenAI service is enabled for your subscription

If you do not have an Azure account, you can create one from the Azure website.

Step 1: Create Azure OpenAI Resource

First, you need to create an Azure OpenAI resource.

Open the Azure Portal:

https://portal.azure.com

Steps

Login to the Azure Portal.
In the search bar, type Azure OpenAI.
Click Create.

Now fill the required fields.

Configuration

Resource Group

Create a new resource group or select an existing one.

Region

Choose a supported region such as:

East US
Sweden Central

Name

Enter a unique resource name.

Example:

openai-demo

Use our Online Code Editor

Pricing Tier

Select Standard.

After filling the details:

Click Review + Create

Then click Create to deploy the resource.

Deployment usually takes around one to two minutes.

Step 2: Deploy a Model

Once the resource is created, you need to deploy a model.

Steps

Open the Azure OpenAI resource you created.
In the left menu, click Model Deployments.
Click Deploy Model.

Now select a model.

Recommended Models

For most applications, these models work well:

gpt-4o-mini

Fast and cost efficient model.

gpt-35-turbo

Popular chat model.

Deployment Configuration

Model

Select the model you want.

Deployment Name

Example:

gpt-4o-mini

Use our Online Code Editor

Click Deploy.

Azure will now create the model deployment.

Step 3: Get API Credentials

To call the Azure OpenAI API from your application, you need an API key and endpoint.

Steps

Open the Azure OpenAI resource.
Click Keys and Endpoint.

You will see the following information.

API Key 1

API Key 2

Endpoint

Example:

API KEY
xxxxxxxxxxxxxxxxxxxxxxxx

ENDPOINT
https://openai-demo.openai.azure.com/

Use our Online Code Editor

You can use either Key 1 or Key 2 in your application.

Example API Endpoint

Your application will send requests to the endpoint.

Example:

https://openai-demo.openai.azure.com/openai/deployments/gpt-4o-mini/chat/completions?api-version=2024-02-15-preview

Use our Online Code Editor

Your request must include:

API Key
Endpoint
Deployment Name

Conclusion

Azure OpenAI makes it easy to use powerful AI models in enterprise applications. The basic process involves three steps:

Create an Azure OpenAI resource
Deploy a model such as gpt-4o-mini
Get API credentials and endpoint

Once these steps are completed, you can start building AI-powered applications using Azure OpenAI.

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.

Mastering @PathVariable in Spring Boot

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

Learn how to use @PathVariable in Spring Boot to build clean and RESTful APIs with practical examples from real-world scenarios like users, products, and orders.

What is `@PathVariable`

@PathVariable in Spring Boot is an annotation used to bind values from the URL directly to method parameters in a controller. It is mainly used in REST APIs where resources are identified using hierarchical URLs. For example, in /users/101, the value 101 represents a specific user and is captured using @PathVariable.

@PathVariable is used in Spring Boot to extract values from the URL path and bind them to method parameters to identify specific resources in REST APIs.

It differs from query parameters because it is part of the URL path, making APIs more readable and meaningful. In real-world systems like e-commerce or CRM, it is commonly used to fetch specific records, such as a user, product, or order, by ID. It also supports multiple values and even dynamic mapping using a Map structure when needed.

In Spring Boot, @PathVariable is used to extract dynamic values from the URL. It helps in designing RESTful APIs where resources are clearly identified using URL paths instead of query parameters.

Let’s start with a simple example:

@GetMapping("/users/{userId}")
public String getUser(@PathVariable Long userId) {
    return "User ID: " + userId;
}

Use our Online Code Editor

When a request like /users/101 is made, Spring automatically maps 101 to the userId variable.

Now consider a real-world scenario in an e-commerce system where a user wants to view a specific product:

@GetMapping("/users/{userId}/products/{productId}")
public String getUserProduct(@PathVariable Long userId,
                             @PathVariable Long productId) {
    return "User: " + userId + ", Product: " + productId;
}

Use our Online Code Editor

This makes the API intuitive and readable.

You can also customize variable names:

@GetMapping("/users/{userId}/orders/{orderId}")
public String getOrder(@PathVariable(name = "userId") Long id,
                       @PathVariable Long orderId) {
    return "User: " + id + ", Order: " + orderId;
}

Use our Online Code Editor

For dynamic cases, you can use a Map:

@GetMapping("/users/{userId}/address/{addressId}")
public String getAddress(@PathVariable Map<String, String> pathVars) {
    return "User: " + pathVars.get("userId") +
           ", Address: " + pathVars.get("addressId");
}

Use our Online Code Editor

This is useful when handling flexible URLs.

In real-world applications like CRM or booking systems, @PathVariable is used to fetch user details, order history, or product information based on unique identifiers.

Best practices include using meaningful variable names, avoiding too many path variables in one endpoint, and validating inputs properly. Also, prefer strongly typed variables over Map when possible.

Using @PathVariable correctly improves API clarity, maintainability, and aligns with REST standards followed in production-grade applications.

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.

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.

DEV Community: Jane

Difference Between OpenAI API Key and Azure OpenAI API Key

OpenAI API Key

Steps to Get OpenAI API Key

Azure OpenAI API Key

Key Differences

When to Use OpenAI

When to Use Azure OpenAI

Conclusion

Author: Ayush Shrivastava

Thank you for being a part of the community

Whenever you’re ready

How to Create an Azure OpenAI Resource and Deploy Your First Model.

Prerequisites

Step 1: Create Azure OpenAI Resource

Steps

Configuration

Step 2: Deploy a Model

Steps

Recommended Models

Deployment Configuration

Step 3: Get API Credentials

Steps

Example API Endpoint

Conclusion

Author: Ayush Shrivastava

Thank you for being a part of the community

Whenever you’re ready

Mastering @PathVariable in Spring Boot

What is @PathVariable

Author: Ayush Shrivastava

Thank you for being a part of the community

Whenever you’re ready

TOP 5 Books Every Backend Developer Should Read

1. Designing Data-Intensive Applications by Martin Kleppmann

2. Clean Code by Robert C. Martin

3. Cracking the Coding Interview by Gayle Laakmann McDowell

4. Fundamentals of Software Architecture by Richard and Ford

5. Grokking Algorithms by Aditya Bhargava

Conclusion

Author: Amanda Ene Adoyi

Thank you for being a part of the community

Whenever you’re ready

Persistent Chat History with Database Design (Practical Example)

Example Schema for a Chat Application

Sample Data Model for Conversations and Messages

Writing and Reading Chat Messages Step by Step

Optimizing Queries for Real-Time Chat Apps

Author: Toluwanimi Fawole

Thank you for being a part of the community

Whenever you’re ready

Authentication & Session Management for AI Apps

API Key Authentication for AI Services

Token-Based Authentication Using JWT

OAuth and Social Login for AI Platforms

Passwordless Authentication for AI Apps

Author: Toluwanimi Fawole

Thank you for being a part of the community

Whenever you’re ready

Top 5 Java Backend Development Courses (2026)

Top 5 Java Backend Development Courses 2025

1. Become a Java+Spring Backend Developer

Course Highlights:

2. Mastering Java Backend with Oracle University

3. Learn Java by Creating Applications

Course Highlights:

4. Become a Java Backend Developer Bootcamp

Bootcamp Outline:

Bootcamp Highlights:

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

Course Highlights:

Final Thoughts

Ready to Become a Java Backend Engineer?

Author: Solomon Eseme

Thank you for being a part of the community

Whenever you’re ready

Which AI Skills Actually Get You Hired in 2026?

"How to Land AI Engineering Jobs."

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

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

What is `@PathVariable`

Introducing `std::default::Default`

Implementing `Default`