Introduction
Calculating the average Sea Surface Temperature (SST) from your dataset is essential, especially when data may be missing. In this guide, we'll discuss how to efficiently compute the average SST for a 30-day period in MATLAB, even when faced with missing data represented as NaN values.
Understanding the Problem
When dealing with SST data over a period, it is common to encounter gaps due to missing observations or anomalies. These missing values, typically denoted as NaN in MATLAB arrays, can throw off calculations if not handled properly. The good news is that MATLAB provides built-in functions to help us manage these missing values, making it possible to still compute an average from the available data.
Steps to Calculate Average SST
Step 1: Load Your SST DataFirst, you need to load your SST data from the .mat file into the MATLAB workspace. Use the following code snippet:load('yourdata.mat'); % replace 'yourdata' with the name of your file
Assuming your SST data is stored in a variable named SST, you can check its structure using:whos SST
This command will give you a summary of the variable.Step 2: Handle Missing DataBefore calculating the average, it's crucial to verify how the missing data is represented. You'll typically find NaN values. To deal with these, you can use the nanmean function from the Statistics and Machine Learning Toolbox, or you can manually filter the data using other methods if this toolbox is not available.Step 3: Calculate the AverageUsing nanmean, you can compute the average as follows:averageSST = nanmean(SST);
Alternatively, if you want a solution that doesn't depend on additional toolboxes, you can do this manually:validData = SST(~isnan(SST)); % Remove NaN values
averageSST = mean(validData); % Calculate the average of the valid data
Step 4: Display the ResultsOnce you've computed the average, you can display it using:disp(['The average SST over 30 days is: ', num2str(averageSST)]);
Example CodePutting it all together, here's a sample MATLAB code:% Load sst data
load('yourdata.mat');

% Calculate average SST
averageSST = nanmean(SST);

% Display the result
disp(['The average SST over 30 days is: ', num2str(averageSST)]);

Frequently Asked Questions
What if I have more than one variable in my .mat file?You can list all variables using the whos command after loading the data. Access the relevant variable using SST = yourVariableName; accordingly.Can I visualize the SST data along with the average?Absolutely! You can plot the data with missing values marked as gaps. Use:plot(SST);
hold on;
plot(averageSST * ones(size(SST)), 'r--'); % Plot average as a red dashed line
hold off;
What if nanmean is not working for me?Ensure that you have the Statistics and Machine Learning Toolbox installed. If not, use the manual method to filter out NaN values.
Conclusion
Calculating the average SST over 30 days in MATLAB, despite missing data, is straightforward. By using built-in functions or manual methods, you can derive meaningful insights from partially complete datasets. This process can be crucial for further analyses and decision-making in various environmental studies.

If your organization relies on software to deliver value, APIs are already at the epicenter of your digital infrastructure. They connect your systems, enabling you to scale through integration and automation and deliver superior customer experiences. But what’s often overlooked is that APIs are only as reliable as your ability to test them effectively. Unlike traditional UI testing, which focuses on the frontend layer, testing them gives you visibility into the actual mechanics of your app—the business logic, the rules that drive decisions, and the integrations that connect your systems. If you don’t validate that layer thoroughly, you leave core functionality exposed, increasing security risk. In this blog post, we’ll explore API testing in detail: its types, benefits, prerequisites, best practices, and more. We’ll also touch on how AI for software testing is transforming the way teams approach API validation. But first, let’s start with the basics.


What is API Testing?
API testing refers to the process of validating the core functionality of your software—independent of the user interface.Rather than interacting with screens, forms, or buttons, you test how the app responds to direct requests sent to its API endpoints and the outcomes produced—whether JSON, XML, or another structured format.You can automate API testing early in the development life cycle, run it frequently, and trust the results.


When and Where API Testing Happens
An integral part of running API tests is to understand where they fit within your app architecture and when they deliver the most strategic value.Most enterprise systems are structured across three primary layers:
The data layer
The user interface (UI)
The business logic layer (which governs how data is processed, rules are enforced, and services interact)
While the UI layer often changes to support evolving customer experiences, the business layer represents your core logic, usually encapsulated in services and exposed through APIs reused across channels, products, or even business units.In practical terms, API testing should begin as soon as the API contract is defined and endpoints become available, often before the UI is built. This enables frontend and backend teams to work in parallel, with backend validation running early and continuously.Moreover, during development, API testing supports immediate feedback for individual endpoints. During integration, it ensures APIs work reliably across services and teams.It also provides assurance that APIs meet performance and security expectations under real-world conditions in staging or production-like environments.


Benefits of API Testing
Why API testing is important, you ask?The advantages of running API tests are directly reflected in your delivery velocity, system reliability, and the overall resilience of your software ecosystem.1. Optimized test coverageAPI testing improves test coverage in ways UI testing simply can’t. You can test edge cases, simulate unexpected inputs, and directly validate the behavior of each business logic layer. This is particularly valuable in complex microservices-based environments where testing via the UI would be either inefficient or incomplete.2. Quick quality assuranceDecouple your QA automation efforts from the user interface. Parallelize work streams across frontend and backend teams, test third-party integrations independently and support continuous testing across distributed teams and environments. API testing gives you operational flexibility.3. Supports automationAPI testing is inherently automation-friendly. Unlike UI tests, which are often fragile and slow to maintain, these tests are faster, more stable, and less prone to false positives. You can develop a reliable automated regression suite that integrates seamlessly with CI/CD pipelines. Your team receives feedback continuously without slowing down deployments.4. Language-agnosticSince APIs exchange data via XML or JSON formats, all languages can be used during API testing. Whether you prefer Java, JavaScript, Python, Ruby, or PHP, you can use any programming language your developers and testers are most comfortable with. This also allows you to maintain control even as your tech stack evolves.5. GUI independence
Since APIs operate independently of the UI, you can begin testing when the endpoints are stable. This means even before a single screen is built. This accelerates defect detection and enables you to resolve issues when they’re the cheapest and easiest to fix.


Types of API Testing
API testing isn’t one-size-fits-all. It encompasses various types of tests that you should run, including:1. Load testingThis pushes your APIs under volume, concurrency, and time-based pressure. Load testing tools aim to uncover how the system behaves under expected volume and whether it scales predictably. You need to know where the limits are, how the system handles peak demand, and whether it can recover quickly from overload.2. Performance testingSuch tests focus on response times, latency, and throughput under known conditions. You conduct performance testing to benchmark improvements, identify bottlenecks, and ensure your APIs consistently meet service-level expectations.3. End-to-end (E2E) testingThis validates how APIs behave as part of a complete system workflow. E2E testing is especially relevant in microservices environments or composite apps where multiple APIs interact. You use E2E tests to verify that state changes, business rules, and data flow hold true when APIs are chained together in production-like scenarios.4. Security testingThis is essential if your APIs handle sensitive data, support user authentication, or interact with third-party services. You test encryption, input sanitization, and authorization logic. Two types of tests fall under security testing:

Penetration testing: Simulates attacks by exploiting potential vulnerabilities from an attacker’s perspective

Fuzz testing: Feeds the API endpoints with invalid, unexpected, or random data to surface unhandled exceptions or potential exploit vectors
5. Validation testingThis ensures the API does what it was intended to do. You use it to confirm the API aligns with business requirements, handles data correctly, and adheres to specifications. Validation testing confirms that the API is fit for purpose and free from unnecessary complexity or feature bloat.6. Functional testingIt focuses on individual endpoints and expected use cases. Functional testing confirms that your APIs return the correct responses under defined conditions and fail when presented with unexpected or invalid inputs.Such tests verify core logic, ensure consistent behavior, and are generally automated to run on every build, making them the backbone of any API test suite.


Prerequisites for API Testing: How to Do API Testing
Let’s review everything you need to take API tests effectively.1. Team understanding of APIs and automationYour team should first understand the APIs to be tested. This includes the structure of request and response payloads, authentication mechanisms, expected side effects, and interdependencies across services.To help with this, create API documentation offering a detailed overview of the API’s functions. Outline the available endpoints, describe the expected request and response formats, and list potential error codes that might be encountered.If your testers or software engineers are unclear about the API’s role in the broader app architecture, their tests will be vague or have ambiguity. To ensure alignment on success, promote cross-collaboration between developers, testers, product owners, and architects.2. Proper test environment setupYour testing environment should mirror production conditions as closely as possible. This means stable API endpoints, realistic data, properly configured authentication, and clean separation from test data to prevent any impact on live environments.Otherwise, test outcomes can be skewed, turning defect analysis into guesswork. Your CI/CD pipeline should also be configured to run these tests automatically at relevant stages, ideally on every commit or deployment to a staging environment.Here’s an example:Context: Testing ‘GET /orders/{id}’ for an eCommerce app

Environment: Staging environment replicating production config (same API gateway, auth method, and DB structure)

Test Data: Uses mock customer orders created via setup scripts, isolated from live production data

Authentication: OAuth 2.0 access tokens generated from a test identity provider

CI/CD: Tests triggered automatically on every pull request merge to the ‘staging’ branch
3. Defined test plan and expected resultsClearly define a test plan articulating what you’re testing. It’s how you ensure your api testing efforts are targeted, consistent, and aligned with business priorities. For example:

Test: ‘POST /users’ creates a new user

Input: Valid name, email, and password

Expected: ‘201 Created,’ user ID in response, user saved in DB
A well-defined plan helps prevent redundant effort, clarifies ownership, and serves as a communication layer between technical and non-technical stakeholders.4. Data configuration and output structureYou need discipline in how you define unexpected results. If your assertions are vague or over-reliant on status codes alone, you miss deeper issues related to data integrity, business rule enforcement, or cross-service dependencies. For example:Poor assertion: Test passes if response status is ‘200 OK’Better assertion: Test passes if:
Status is ‘200 OK’
The response body includes a valid ‘orderId’
‘status’ is “confirmed”
‘totalAmount’ matches the expected value from the input data
Status codes don’t verify that the system enforced the right business logic or returned accurate data. When expected results are precise, failures point directly to what went wrong.


Common Test Cases in API Testing
The quality of your test cases largely determines the effectiveness of your API testing effort. Here’s how to perform API testing right.1. Response payloadsThis refers to the data sent back from a server to a client after a request, comprising the requested information or indicating the outcome of the operation. Here, you check if keys are present, values make sense, and nothing important gets missed.2. Schema validationHere, you validate the structure of the response. If the API is supposed to return a list of users with ‘id’ as an integer and ‘email’ as a string, you test that structure exactly. It helps catch issues when the backend changes something unexpectedly.3. Database integrityThis ensures that the API’s actions (create, update, and delete) are reflected in the database correctly. After an API call, you double-check the DB to ensure the operation didn’t break any constraints or relationships or leave bad data behind.4. HTTP status codesHTTP status codes indicate the result of an API request.HTTP methods like GET, POST, PUT, and DELETE define the type of action being performed. A successful GET request typically returns a 200 OK, while a successful POST request (used to create a resource) usually returns 201 Created.A 500 Internal Server Error indicates a server-side issue and should not occur during normal, valid operations. A 400 Bad Request suggests the client sent a malformed or invalid request.5. CRUD operationsCRUD stands for Create, Read, Update, and Delete. You test each action separately to ensure the API supports basic data manipulation correctly and consistently. This is the most direct way to confirm that the core functionality works, maintains data integrity, and properly manages the state.6. Error handlingIntentionally sending malformed or invalid requests helps ensure the API returns proper error responses.These should include an appropriate status code (e.g., 400 for bad requests, 401 for unauthorized access), structured error messages, and ideally, a human-readable explanation or an error code for debugging. This test ensures developers aren’t left guessing during API testing.7. File uploadsIf your API allows file uploads, you test whether files are uploaded and stored correctly and whether limits (size and format) are enforced. Your tests should confirm the API’s response, validate file persistence (e.g., storage location, file metadata), and verify any corresponding changes to the database (if applicable.)8. Edge casesHere, you test how well the API handles unexpected or extreme input without breaking. Try different combinations of data, entry input, special characters, or massive payloads to verify API performance.


Best Practices (and the Challenges They Solve) in API Testing
Here’s how to achieve API test effectiveness at scale—minus the challenges.1. Organize test cases by categoryAs your test suite grows, it becomes a mess to manage. That’s why it’s vital to write and organize test cases by category. Instead of going through a pile of unrelated tests, you’ll know exactly where to find what. For instance, you could have folders or tags like ‘user management,’ ‘orders,’ and ‘payments.’2. Make tests self-containedTests that depend on each other are fragile and fail unpredictably. Therefore, each test should be self-contained so it sets and cleans up its data. Imagine testing an “Update User” endpoint. Don’t already assume a user exists.Instead, have the test create a user, update it, and delete it if needed. This allows you to run the tests alone or in any order, and they still work.3. Avoid test chaining (unless intentional)Chained tests create a domino effect when one thing fails. Avoid test chaining unless you intentionally want to test a complete workflow. If your “Get Product” test relies on a “Create Product” test, and that first one breaks, you chase multiple failures for one issue.Chaining is acceptable if you specifically test a multi-step checkout flow, like the following.“Add to Cart → Checkout → Confirm Order”4. Prioritize call sequences correctlyAPIs often need to be called in a specific order, and testing them out of sequence results in confusing errors. Prioritize your API calls. For instance, don’t test “Delete Order” before testing “Create Order.” Think logically. If the item doesn’t exist, the deleted test will fail not because of an actual bug but because of poor sequencing.5. Validate a wide range of inputsIf you only test the perfect-case scenarios, you’ll miss accounting for real-world problems, such as unexpected behaviors, bad input, network hiccups, and more. You should validate various inputs: valid, invalid, empty, too long, and too short.If you’re testing a login endpoint, try a correct password, a wrong one, and a blank field. This helps you catch unexpected user behaviors, not just the obvious ones.6. Handle one-time destructive calls (e.g., Delete)Some API calls change state in a way that can’t be undone. Handle one-time destructive calls carefully. If you test a “Delete Account” endpoint, test the data you can afford to lose. You might even want to use mocks or run this in a sandbox environment.7. Watch for schema version driftAPIs evolve, and when the schema changes, tests silently break. Therefore, watch for schema version drift during api testing. Always validate the API response against the defined schema version. Tools like OpenAPI (and its extensions like Swagger) enable strict contract testing, ensuring your API remains backward-compatible.If the schema changes, versioning or changelog tracking is essential to avoid breaking consumers. If a field changes or disappears, you want your test to catch that right away. Otherwise, your app’s frontend will expect a field that no longer exists.


Conclusion: Deliver High-Quality APIs Consistently With API Testing
In an environment where software is both your product and your platform, testing APIs is mission-critical. Failing to do so exposes your app to avoidable risks, such as service outages, security vulnerabilities, data corruption, and degraded customer experiences.With API testing, you gain earlier insight into system health, minimize your dependence on fragile UI-level tests, and create space for parallel work streams between frontend and backend teams. You increase the quality and reliability of your software. Therefore, implement performance evaluations early in the development process. Source: This article was originally published on TestGrid.

As part of the Google GenAI Exchange Program, I completed the course "Inspect Rich Documents with Gemini Multimodality and Multimodal RAG", which dives into the power of multimodal AI for document inspection and analysis.Gemini Multimodality combines the capabilities of language models with image and document analysis, enabling AI to understand not just text, but images and other media within documents. The course introduced me to Multimodal RAG (Retrieval-Augmented Generation), a method that enhances AI’s ability to retrieve and generate information from multiple sources, making document inspection smarter and more efficient.Through this course, I learned how to apply these techniques for document parsing, intelligent search, and extracting insights from complex datasets. By integrating Gemini’s multimodal capabilities, I can now inspect and analyze rich documents, unlocking new possibilities in document automation, content generation, and knowledge extraction.