Blog

In modern web application development, interacting with a database is a core requirement. Spring Boot integrates seamlessly with Spring Data JPA, providing a robust way to manage data persistence with significantly less code. This section explains Spring Data JPA, how it works, practical examples, and its benefits.

I. What is Spring Data JPA?

Spring Data JPA is a powerful framework that helps you:

• Simplify Database Operations: Perform CRUD (Create, Read, Update, Delete) operations without writing complex SQL.
• Eliminate Boilerplate: Reduce the need for DAO (Data Access Object) implementation classes.
• Automatic Query Generation: Create database queries simply by defining method names in an interface.
• Support Pagination and Sorting: Manage large datasets efficiently with built-in tools.

By adding the spring-boot-starter-data-jpa dependency, Spring Boot configures a production-ready data layer automatically.

II. How Does Spring Data JPA Work?

Spring Data JPA acts as an abstraction layer on top of JPA (Java Persistence API) and Hibernate:

• The Repository Pattern: It uses interfaces to provide a standard way to access data.
• Proxy Mechanism: At runtime, Spring Boot automatically creates an implementation for your repository interfaces.
• Method Name Parsing: When you define a method like findByEmail(String email), the framework parses the name and generates the appropriate JPQL (Java Persistence Query Language) or SQL query.
• Transaction Management: It handles database transactions automatically, ensuring data integrity.

III. How to Use Spring Data JPA

1. Add Dependency

Maven:

<dependency>   <groupId>org.springframework.boot</groupId>   <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency>   <groupId>com.h2database</groupId><artifactId>h2</artifactId>   <scope>runtime</scope> </dependency>

 

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-data-jpa' runtimeOnly 'com.h2database:h2'

 

2. Define an Entity

An Entity represents a table in your database:

@Entity public class Product {      @Id      @GeneratedValue(strategy = GenerationType.IDENTITY)      private Long id;      private String name;      private Double price;                 // Getters and Setters }

3. Create a Repository Interface

By extending JpaRepository, you gain access to all standard CRUD operations.

@Repository public interface ProductRepository extends JpaRepository<Product, Long> {     // Automatically generates: SELECT * FROM product WHERE name = ?     List<Product> findByName(String name);       // Custom query using @Query     @Query("SELECT p FROM Product p WHERE p.price > :minPrice")     List<Product> findExpensiveProducts(@Param("minPrice") Double minPrice); }

 

IV. Example of Spring Data JPA in Action

Managing products in a Service layer:

@Service public class ProductService {     @Autowired     private ProductRepository productRepository;       public Product saveProduct(Product product) {         return productRepository.save(product); // Saves or Updates               }                 public List<Product> getProductsByName(String name) {                   return productRepository.findByName(name);               } }

When calling productRepository.findAll(PageRequest.of(0, 10)), Spring Data JPA handles the SQL "LIMIT" and "OFFSET" logic behind the scenes.

V. Benefits of Spring Data JPA

• Development Speed: Write only interfaces; let the framework handle the implementation.
• Reduced Errors: Automatic query generation prevents common syntax errors in SQL.
• Easy Pagination: Built-in support for Pageable and Sort makes UI integration simple.
• Vendor Independence: Easily switch between different databases (H2, MySQL, PostgreSQL) with minimal configuration changes.
• Seamless Integration: Works perfectly with Spring Security for data-level protection and Spring Boot Auto-Configuration.

VI. Conclusion

Spring Data JPA allows you to manage your application's data layer with elegance and efficiency. It removes the burden of repetitive data access code, allowing developers to focus on building features rather than debugging SQL strings.

Whether you need scalable software solutions, expert IT outsourcing, or a long-term development partner, ISB Vietnam is here to deliver. Let’s build something great together—reach out to us today. Or click here to explore more ISB Vietnam's case studies.

[References]

https://spring.io/projects/spring-data-jpa

https://docs.spring.io/spring-data/jpa/docs/current/reference/html/

https://www.baeldung.com/the-persistence-layer-with-spring-data-jpa

https://spring.io/guides/gs/accessing-data-jpa/

After completing the AZ‑900 certification, I realized that Microsoft Azure is far more than a cloud platform—it’s a well‑designed ecosystem built to support modern applications at scale. In this article, I’ll introduce Azure using the same structured framework I studied for AZ‑900, but with a stronger focus on practical, real‑world understanding from a developer’s perspective.

I. Understanding Cloud Concepts Before Using the Cloud

Before deploying anything, it is essential to understand what cloud computing actually provides.

Microsoft Azure is a cloud computing platform developed by Microsoft that offers on-demand computing resources over the internet. Instead of managing physical servers, developers provision infrastructure and services dynamically.

Service Models

Azure services are generally categorized into three cloud models:

• IaaS (Infrastructure as a Service)
  Infrastructure as a service gives you maximum control over your cloud environment because you manage almost everything except the physical hardware. The provider handles the datacenter equipment, internet connectivity, and on‑site security, while you take charge of installing and maintaining operating systems, configuring networks, setting up storage and databases, and managing applications. In practice, it’s like renting servers and networking gear in someone else’s datacenter, with full freedom to decide how those resources are used.
  Example: Running a Linux server on Azure Virtual Machines.
• PaaS (Platform as a Service)
  Platform as a service can be described as a cloud model that sits between IaaS and SaaS, giving you a managed environment for building and running applications without dealing with the underlying system layers. The provider takes care of the physical servers, security, networking, and also the software stack that supports development—such as operating systems, middleware, runtime environments, and analytics tools. Because these layers are handled for you, you don’t need to manage licenses, updates, or patches for the OS or databases.
  Example: Deploying a web application on Azure App Service.
• SaaS (Software as a Service)
  Software as a service refers to using a fully built, ready‑to‑use application that runs in the cloud. Instead of installing or managing the software yourself, you simply access it—common examples include email services, accounting tools, messaging platforms, and collaboration apps. Because everything is already developed and maintained by the provider, you’re essentially subscribing to a complete product.

Even though SaaS offers the least customization, it’s also the simplest and fastest model to adopt. It requires minimal technical skill because all updates, maintenance, and infrastructure responsibilities are handled for you.
Example: Microsoft 365.

II. Networking and Storage

Azure Networking

Azure’s networking services provide the core connectivity that allows your cloud resources to communicate securely and efficiently. At the foundation are services like Virtual Networks (VNets), Private Link, Azure DNS, Bastion, Route Server, NAT Gateway, and Traffic Manager, which together create a customizable and secure network environment for your applications. These tools let you isolate workloads, manage routing, control inbound and outbound traffic, and connect on‑premises networks to Azure.

Beyond basic connectivity, Azure also offers load balancing and content delivery capabilities—such as Load Balancer, Application Gateway, and Azure Front Door—to distribute traffic, improve performance, and ensure high availability. These services help optimize how applications respond to user requests, whether they’re internal workloads or global web applications.

Security is built into the networking layer through features like network security groups, firewalls, and private endpoints, allowing you to tightly control which resources can communicate and how that communication happens.

Azure Storage

Azure Storage is Microsoft’s cloud‑based platform for storing and managing data at massive scale. It’s designed to be highly available, durable, secure, and globally accessible, making it suitable for everything from simple file storage to large‑scale analytics workloads. Azure Storage supports multiple data types and offers tools that developers and IT teams can use from anywhere via HTTP/HTTPS and REST APIs.

Core Characteristics:

• Massive scalability — Designed to grow with your data needs, from gigabytes to petabytes.
• High durability and availability — Multiple copies of your data are stored to protect against failures.
• Strong security — Encryption, network isolation, and identity-based access controls are built in.
• Global accessibility — Data can be accessed from anywhere over secure HTTP/HTTPS endpoints.
• Developer-friendly — Supports REST APIs and client libraries for .NET, Java, Python, JavaScript, C++, and Go.

Azure maintains extra copies of your data to ensure availability and durability, even when failures occur. These failures can include hardware issues, power or network outages, or natural disasters. Choosing a redundancy option is a balance between cost, performance, and resilience.

Redundancy within the primary region

These options keep your data inside a single Azure region.

- Locally Redundant Storage (LRS) — Your data is copied three times within a single datacenter. It’s the most cost‑effective option but doesn’t protect against a full datacenter outage.

- Zone‑Redundant Storage (ZRS) — Your data is stored across three separate availability zones within the same region. This protects against datacenter‑level failures while staying within one region.

Redundancy across regions

These options replicate your data to a geographically distant secondary region.

- Geo‑Redundant Storage (GRS) — Your data is stored three times in the primary region (like LRS) and then copied to a secondary region for disaster recovery.

- Read‑Access Geo‑Redundant Storage (RA‑GRS) — Same as GRS, but you can read from the secondary region. This improves availability during regional outages.

III. Security and Identity

Azure security and identity in the cloud revolve around protecting access to resources through strong authentication, authorization, and continuous threat-aware controls. At the center of this model is Microsoft Entra ID, which provides identity management, single sign‑on, multifactor authentication, and role‑based access control to ensure that only the right people and applications can reach the right resources.

Security Concepts in Azure

Azure security concepts center on protecting identities, data, applications, and infrastructure through a multilayered, defense‑in‑depth approach. This model combines built‑in platform protections, shared responsibility between Microsoft and customers, and advanced security services that detect and respond to threats. Azure emphasizes securing every layer—from physical datacenters to identities, networks, and workloads—because cloud environments face constantly evolving cyber risks.

Defense in depth

Azure applies multiple layers of protection across physical, network, identity, application, and data layers. If one layer is compromised, others continue to protect the environment. This includes secure datacenters, network segmentation, identity controls, encryption, and monitoring.

The Zero Trust model

Zero Trust treats every network—internal or external—as untrusted, so no user or device is assumed safe by default. It follows the idea of “never trust, always verify,” meaning every access request must be authenticated, authorized, and continuously validated before anything is granted.

Data protection

One way to mitigate against common cybersecurity threats is to encrypt sensitive or valuable data. Encryption is the process of making data unreadable and unusable to unauthorized viewers. To use or read encrypted data, it must be decrypted, which requires the use of a secret key.

Shared responsibility model

Microsoft secures the physical infrastructure, hosts, and foundational services, while customers secure their identities, data, applications, and configurations. Understanding this division is essential for building a secure cloud environment.

Core Identity Concepts in Azure

Identity management

Identity management ensures that every user, device, or application accessing Azure resources is properly authenticated and authorized. Microsoft Entra ID acts as the cloud identity provider, extending on‑premises Active Directory to the cloud and enabling unified access across thousands of SaaS and on‑premises applications.

Single sign‑on (SSO)

SSO allows users to sign in once and access multiple applications without repeatedly entering credentials. This reduces password fatigue and improves security by minimizing exposed credentials. Entra ID supports SSO for a wide range of cloud and on‑premises apps.

Multifactor authentication (MFA)

MFA adds a second verification step—such as an authenticator app, biometric sign‑in, or security key—to strengthen protection against unauthorized access. It provides a critical extra layer of defense while keeping the sign‑in experience smooth.

Role‑based access control (RBAC)

RBAC assigns permissions based on roles rather than individual accounts, ensuring users only have the access they need. This supports the principle of least privilege and helps reduce accidental or malicious misuse of resources.

Additional security capabilities

Azure identity and security services also support modern frameworks such as Zero Trust and conditional access, which evaluate user identity, device health, location, and risk signals before granting access. These approaches help organizations defend against evolving threats.

IV. Pricing Model and Operational Flexibility

Azure Pricing Model

Pay‑as‑you‑go

You are billed based on actual consumption with no upfront commitment. This is ideal for workloads that change frequently because you can scale resources up or down instantly.

Reserved capacity

You commit to using a service (such as virtual machines or databases) for one or three years in exchange for a lower price. This is best for predictable, always‑on workloads.

Spot pricing

You use unused Azure capacity at a steep discount, with the understanding that Azure can reclaim the resources at any time. This works well for batch jobs, testing, or workloads that can tolerate interruptions.

What affects cost

• Service type (compute, storage, networking)
• Region where the service runs
• Performance tier
• Data transfer
• Duration of usage

These factors allow organizations to tailor spending to their technical and financial goals.

Operational Flexibility in Azure

Elastic scalability

Azure resources can automatically scale based on demand. This prevents overprovisioning and reduces wasted cost.

Global deployment

Azure’s worldwide datacenter network lets you run applications close to users, improving performance and offering redundancy options.

Multiple service tiers

Most Azure services offer different performance levels, allowing you to choose between cost‑optimized or high‑performance configurations.

Cost management tools

Azure provides budgeting, monitoring, and optimization tools to help track spending and identify savings opportunities.

V. What AZ-900 Changed in My Perspective

Studying for AZ-900 was not just about passing an exam. It helped me structure cloud knowledge into:

1. Concepts
2. Services
3. Security
4. Cost management

More importantly, it shifted my mindset from “managing servers” to “designing scalable systems.”

VI. Conclusion

Microsoft Azure is not just a collection of cloud services. It is a comprehensive ecosystem designed to support modern software architectures — from startups to global enterprises.

For developers transitioning from traditional infrastructure or embedded systems to cloud-native environments, Azure provides a structured path forward.

Earning AZ-900 was only the beginning. The real value comes from applying these concepts in real-world architectures.

References:

https://learn.microsoft.com/en-us/training/modules/describe-cloud-service-types/2-describe-infrastructure-service

https://learn.microsoft.com/en-us/training/modules/describe-cloud-service-types/3-describe-platform-service

https://learn.microsoft.com/en-us/training/modules/describe-cloud-service-types/4-describe-software-service

https://learn.microsoft.com/en-us/training/modules/describe-azure-compute-networking-services/8-virtual-network

https://learn.microsoft.com/en-us/training/modules/describe-security-concepts-methodologies/3-describe-defense-depth

https://learn.microsoft.com/en-us/training/modules/describe-security-concepts-methodologies/4-describe-zero-trust-model

https://learn.microsoft.com/en-us/training/modules/describe-security-concepts-methodologies/5-describe-encryption-hashing

https://learn.microsoft.com/en-us/training/modules/describe-security-concepts-methodologies/2-describe-shared-responsibility-model

https://learn.microsoft.com/en-us/training/modules/describe-identity-principles-concepts/3-define-identity-primary-security-perimeter

https://azure.microsoft.com/en-us/pricing/https://www.swiftorial.com/tutorials/cloud_computing/azurecloud/introduction_to_azurecloud/azure_pricing_models/

After more than 1.5 years working in Manual Testing, I realized that for large-scale systems with long-term development cycles, Regression Testing is a major bottleneck. Manually re-executing test cases is not only repetitive and time-consuming but also highly prone to human error. That is when I knew Automation Testing was the inevitable next step.

If you are also starting as a Manual QC like me, don't worry—it is actually a huge advantage. Here is my journey and some tips from when I first started learning Automation with Playwright using Python.

1. What to Prepare Before Starting

Test Case Writing Skills (The Foundation)

This is an essential skill that every QC needs, whether you do manual or automation testing.

• Proactiveness: If you write your own Test Cases, you will have a better grasp of the requirements (specs). When converting them into scripts, you might discover inconsistencies or gaps in the test cases, allowing you to optimize and update them quickly. If you rely solely on existing Test Cases to write scripts, you might spend too much time trying to understand them. Also, you can't be sure if those Test Cases are still accurate according to the design specs. This makes your scripting process quite passive.
• Know what to automate: Not everything should be automated. Deep business understanding helps in deciding which cases to automate (high repetition, stable) and which to test manually (frequent UI changes, overly complex logic). This saves a lot of wasted effort.

Basic Knowledge

• Programming Language: You don't need to be an expert developer. Start with the core concepts: variables, data types, operators, loops, conditional statements (if/else), and functions. Additionally, grasping basic Object-Oriented Programming (OOP) concepts (like Classes and Objects) is highly recommended. Having basic knowledge of a programming language will make the learning curve smoother when approaching a new test scripting language. You can start with Python because its syntax is very close to natural language, making it extremely easy for beginners to learn.
• Web Knowledge: Explore the HTML/DOM structure and various element attributes to craft effective locators (such as CSS Selectors and XPath). Master the use of browser DevTools (F12) to inspect elements, debug, and monitor Network requests. Additionally, understanding asynchronous mechanisms (Promises, Async/Await) and element states (e.g., visible, enabled) is crucial for leveraging the Auto-wait feature, ensuring that scripts run stably.
• Version Control (Git): Automation test code is as important as the application's source code. Knowing how to use a Version Control System is a must. You don't need to memorize advanced commands right away. Instead, just get used to basic daily tasks: cloning a repository, creating branches for new test cases, saving your changes (commit), and syncing (pull/push) with platforms like GitHub or GitLab. Knowing these basics will make sure you can manage your script versions safely, track your own changes, and work smoothly with other QCs and Developers without code conflicts.

2. Learning Playwright: Key Concepts

When I started with Playwright, these were the most important things I learned:

Project Setup Commands

Before writing any code, you need to install the Playwright library and the browsers it uses to run the tests. In Python, you just need to type these two simple commands into the terminal:

• pip install pytest-playwright: This command installs the Playwright framework along with pytest (a very popular testing tool in Python).

• playwright install: This command downloads the necessary browser engines (like Chromium, Firefox, and WebKit) so Playwright can open them and simulate user actions.

Test Execution Commands 

After writing your test scripts, you need to run them to see if they Pass or Fail. Here are the commands you might use every day:

• pytest: This command runs all your test files silently in the background (this is called Headless mode - no UI is shown, and it is the default setting).

• pytest --headed: This command runs the tests and actually opens the browser window for you to see. This is super helpful for beginners, as it lets you watch the bot clicking and typing on the screen with your own eyes.

• pytest test_login.py: This command only runs one specific test file (for example, the test_login.py file) instead of making the computer run all the files.

Locators (How to find elements)

In the past, QC engineers heavily relied on XPath or CSS Selectors, which can break easily if the DOM structure changes. While Playwright still supports them, it strongly recommends using User-facing Locators—finding elements based on how a user actually perceives them on the screen:

• get_by_role: Locates elements by their implicit role (e.g., button, input) and display name.
  

  Python example: page.get_by_role("button", name="Submit").click()

• get_by_text: Locates elements by the exact text displayed on the screen.
  

  Python example: page.get_by_text("Forgot password").click()

• get_by_label: Locates input fields based on their associated Label (for example, an "Email" field).
  

  Python example: page.get_by_label("Email").fill("test@example.com")

Auto-waiting

This is a "magic" feature. Playwright automatically waits for a button to appear or be ready before clicking it. You don't have to manually write "wait 5 seconds" anymore, which makes your tests much more stable.

Assertions (Checking the results)

To check if a test Passed or Failed, we use expect function.

One of the most powerful features here is auto-retrying assertions. You don't need to write complex code to wait for an element to load. Playwright is smart enough to automatically wait and retry the check until the condition becomes true (or until the timeout is reached).

For example:  

• Checking if a success message is visible on the screen:
  

  Python example: expect(page.get_by_text("Login Successful")).to_be_visible() 

• Checking if an input field contains exactly the expected value:
  

  Python example: expect(page.get_by_label("Email Address")).to_have_value("test@example.com")

• Checking if a specific element is disabled (cannot be clicked):
  

  Python example: expect(page.get_by_role("button", name="Submit")).to_be_disabled()

Read more at: https://playwright.dev/python/docs/test-assertions

3. Automation Support Tools - Work Smarter

Below are the tools that will help you work faster when coding automation test scripts:

• Codegen: This is a "magical" tool for automatic code generation. You simply interact with the web interface, and Playwright automatically records and converts your actions into source code. It is an excellent way to learn syntax during the early stages.
• AI Tools (like Cursor): AI is a powerful asset that can speed up code writing based on Test Cases. By crafting a precise prompt in your desired format and providing the Test Case for reference, the AI will quickly generate the test script. Your remaining tasks are to review, run it with Pytest, and refine the logic, saving you the time of coding line by line.
• UI Mode & Trace Viewer: Don't panic when a script fails. UI Mode and Trace Viewer allow you to replay the "movie" of your test process, inspecting exactly where it failed and seeing the UI state at that moment to find clues for a faster fix.
• Reports: After running tests, Playwright automatically creates a professional HTML report with full statistics: Passed, Failed, Flaky (intermittent)... and can even include screenshots for each case if configured.

4. Next Steps

Once you master these basics, the next challenge is organizing your code. I highly recommend looking into the Page Object Model (POM)—a design pattern that will make your scripts scalable, readable, and much easier to maintain as your project grows.

Final Thoughts

And that’s everything I’ve learned and prepared while getting started with automation testing.

The journey from Manual to Automation isn’t as scary as I first thought. As long as you have a solid foundation in Manual testing, plus a bit of patience with modern tools like Playwright, you’ll find the work becomes much more exciting and rewarding.

Good luck to you (and to me too!) as we push further on this Automation QC path!

In today’s IT world, we are surrounded by AI talk. Whether you are a developer, a project manager, or a IT translator, understanding these concepts is no longer optional—it is essential. However, the technical jargon can be overwhelming. Let’s break down the most important AI terms into simple, real-world ideas.

The Big Picture: AI, ML, and Deep Learning

To understand how AI is built, imagine a set of Russian Dolls (Matryoshka) where one sits inside the other. (Read more about the AI hierarchy).

The largest, outermost doll is Artificial Intelligence (AI). This is the broad goal of creating machines that can mimic human intelligence. In the early days, this was done using fixed rules. Think of a chess-playing robot from the 90s; it didn't "learn" anything, it just followed a long list of "If-Then" instructions written by a human.

Inside that is the middle doll: Machine Learning (ML). This is a smarter way to reach the goal of AI. Instead of writing every rule, we give the machine a massive amount of data and let it find patterns on its own. A classic example is a Spam Filter. You show the system 10,000 "Spam" emails and 10,000 "Real" emails. The machine eventually notices that spam often contains words like "FREE" or "WINNER" and starts blocking them automatically without being told exactly what to look for.

Finally, the smallest doll at the center is Deep Learning (DL). This is the most advanced type of ML, using "Neural Networks" that act like a human brain to handle very messy data. This technology is what powers the Face-Unlock feature on your phone. To recognize your face—even if you grow a beard, wear glasses, or get older—the AI needs the deep, brain-like power of DL to analyze thousands of tiny details in your features.

Moving to language, we often hear about Large Language Models (LLMs). These are specific types of AI, like ChatGPT or Gemini, that are trained on almost everything written on the internet. You can think of an LLM as a super-advanced "Auto-complete." If you type "The capital of France is...", it predicts the next word is "Paris" simply because it has seen that pattern millions of times before.

How AI Goes to School

Before an AI can work, it must undergo a rigorous learning process. This starts with Annotation (or Data Labeling), which we can think of as the "Teacher Phase." AI doesn't inherently understand the world; it needs to be told exactly what it’s looking at. Humans, known as Annotators, must look at thousands of data points and "tag" them.

For example, for a Self-Driving Car to function, humans must manually draw boxes around objects in street photos, labeling them as "Tree," "Stop Sign," or "Pedestrian." This provides the AI with "Ground Truth"—the factual foundation it needs to perceive reality. Without this meticulous human help, the AI is essentially blind.

Once an AI has gained general intelligence, we can give it "extra lessons" through a process called Fine-tuning. Instead of building a new model from scratch, we take a pre-trained general AI and show it a specific dataset—like 5,000 legal contracts. Through this specialization, it stops being a general chatbot and evolves into a Legal AI Specialist that masters the complex nuances of law. This approach is highly efficient, saving both time and massive computing costs.

However, the biggest challenge in AI is a problem called Overfitting. This happens when an AI learns the training data too perfectly—it memorizes the specific examples instead of learning the logic.

To understand this, let’s look at a simple example: Teaching an AI to recognize a "Bird."

Imagine you give the AI thousands of photos of birds to study. However, there is a small problem: every bird in your photos is red.

• Balanced Learning (Correct): The AI looks at the wings, the beak, and the feathers. It understands that a bird is a creature with these specific features.
• Overfitting (The Trap): The AI looks at the color and concludes: "Anything that is red is a bird."

When you test the AI with a photo of a blue bird, the AI will say: "This is NOT a bird" because it isn't red. The AI failed because it didn't learn the "logic" of what a bird is; it only memorized the "color" from your specific photos.

In the IT world, we want our AI to have Generalization—the ability to handle new, unseen situations correctly, rather than just memorizing old data.

Tokens, Memory, and the Art of "Confident Lying"

Once we understand how AI learns, we need to look at how it actually "reads" our instructions. While we see words and sentences, the AI sees the world through Tokens. Think of tokens as the "atoms" of language—small fragments that the AI uses to turn our text into numbers it can calculate. A common word like "apple" might be just one token, but a complex one like "terminology" gets chopped into pieces: termin, olo, and gy.

This isn't just a technical detail; it’s the "currency" of AI. Most AI companies charge you based on how many tokens you send in and how many the AI spits out. Interestingly, for us in the IT world, this means language matters. Because of how AI is built, languages like Vietnamese often require more tokens than English to say the same thing, making the "cost" of a conversation slightly different depending on the language you use.

But these tokens don't just cost money; they also take up space. Every AI model works at what I like to call a Context Window—or its short-term memory. Imagine the AI is a brilliant employee sitting at a very small desk. Every PDF you upload, every old message in the chat, and every instruction you give must fit on that desk for the AI to "see" it.

If your conversation gets too long and exceeds the "desk space," the AI has to start throwing the oldest papers into the trash to make room for new ones. This is exactly why, after a long brainstorming session, the AI might suddenly forget your name or the very first rule you set—it simply ran out of room on its desk.

Nowadays, tech giants are racing to build "giant desks," expanding these context windows so AI can "read" an entire book series in one go. But even with a massive memory, AI has a famous flaw: it loves to tell "confident lies," a phenomenon we call Hallucination.

You see, at its heart, an AI is a high-speed probability engine. It doesn't actually check a "truth database" to see if a fact is real. Instead, it asks itself: "Given the words I've seen so far, what is the most likely next word?" If it doesn't have the exact answer, it won't simply say "I don't know" (unless we tell it to). Instead, it will keep predicting the next word to finish the sentence.

This is how you get professional-sounding answers about non-existent coding functions that look perfect but return an undefined error the moment you run them. The AI prioritizes sounding logical and grammatically perfect over being factually true. For those of us working as Developers or PMs, this is the ultimate reminder: never trust numbers or specific names 100%. Always cross-reference and fact-check.

How do we fix this?

To stop these lies, we use RAG (Retrieval-Augmented Generation). AWS provides a great deep dive into this architecture. Think of this as an "Open Book Exam." Instead of letting the AI guess, a RAG system first searches a reliable source—like your company's handbook—and tells the AI: "Only answer based on this text." We also use Prompt Engineering (giving clear, detailed instructions) and Guardrails (safety fences that block dangerous or wrong answers) to keep the AI on the right track.

Quick Advice for IT Professionals

• Don't trust, verify: Always fact-check names, dates, and code. AI is a master of sounding professional even when it’s wrong.
• Be specific: Treat AI like a smart intern. The more context you give in your prompt, the better the result.
• Watch the tokens: Keep your inputs clean to save costs and avoid hitting the memory limit.

Join the AI Revolution with ISB Vietnam

At ISB Vietnam, we are not just watching the AI revolution—we are leading it. We believe that AI is most powerful when handled by experts who understand its strengths and its "hallucinations." That’s why we are constantly training our developers to master AI tools, ensuring that our software solutions are not just fast, but smart and secure.

Whether you need scalable software solutions, expert IT outsourcing, or a long-term development partner, ISB Vietnam is here to deliver.

Are you a tech talent looking to work in an environment that embraces AI? We are always looking for passionate people to join our team and push the boundaries of what's possible.

• Click here to explore ISB Vietnam's Case Studies
• Visit our Career Page to join our team

Let’s build something great together—reach out to us today!

Image source: Generated by Gemini