{"id":26598,"date":"2025-12-31T11:36:00","date_gmt":"2025-12-31T06:06:00","guid":{"rendered":"https:\/\/www.tftus.com\/?p=26598"},"modified":"2025-12-31T11:36:00","modified_gmt":"2025-12-31T06:06:00","slug":"what-are-different-software-testing-techniques-2","status":"publish","type":"post","link":"https:\/\/stg.tftus.com\/blogs\/what-are-different-software-testing-techniques-2\/","title":{"rendered":"What Is Non Functional Testing in Software Testing \u2013 Process, Tools & Benefits"},"content":{"rendered":"

What Is Non Functional Testing In Software Testing<\/span><\/strong><\/h1>\n

Non-functional testing assesses the effectiveness of the other elements of a software application. It emphasised speed, security, usability, and scalability under various conditions with examples. Non-functional testing provides insights into how well a system performs in a specified environment and after subjecting it to various constraints. Usage testing can detect issues that can impact real users while doing real work, especially when the system is under load, integrated with other tools, or accessed from different platforms. Also, it may crash and bug the system.<\/span><\/p>\n

\"Infographic<\/p>\n

Objectives of Non-functional Testing<\/span><\/strong><\/h2>\n

The objectives of non-functional testing are:<\/span><\/p>\n

    \n
  • Increased usability: <\/span><\/strong>To increase usability, efficiency, maintainability, and portability of the product.<\/span><\/li>\n<\/ul>\n
      \n
    • Reduction in production risk: <\/span><\/strong>To help in the reduction of production risk related to non-functional aspects of the product.<\/span><\/li>\n<\/ul>\n
        \n
      • Cost Reduction: <\/span><\/strong>To help in the reduction of costs related to non-functional aspects of the product.<\/span><\/li>\n<\/ul>\n
          \n
        • Optimize installation: <\/span><\/strong>To optimize the installation, execution, and monitoring way of the product.<\/span><\/li>\n<\/ul>\n
            \n
          • Collect metrics: <\/span><\/strong>To collect and produce measurements and metrics for internal research and development.<\/span><\/li>\n<\/ul>\n
              \n
            • Enhance knowledge of product: <\/span><\/strong>To improve and enhance knowledge of the product behaviour and technologies in use.<\/span><\/li>\n<\/ul>\n

              Non-Functional Testing Parameters:<\/span><\/strong><\/h2>\n

              Let\u2019s find some common non-functional testing parameters. These parameters are often used to ensure a system\u2019s performance, reliability, usability, and other quality attributes.<\/span><\/p>\n

              Security: <\/span><\/strong>This parameter is tested during Security testing. This parameter defines how the system is secure against sudden attacks from internal and external sources.<\/span><\/p>\n

              Reliability: <\/span><\/strong>This parameter is tested during Reliability testing. This defines the extent to which the system performs its intended functions without failure.<\/span><\/p>\n

              Survivability: <\/span><\/strong>This parameter is tested during Recovery testing. This parameter checks that the software system is able to recover itself in the case of failure and continuously performs the specified function without any failure.<\/span><\/p>\n

              Availability: <\/span><\/strong>This is tested during Stability testing. Availability here means the availability percentage of the software system to the original service level agreement. It means the degree to which the user can rely on the software during its operation.<\/span><\/p>\n

              Efficiency: <\/span><\/strong>This parameter means the extent to which the software system can handle the quantity and response time.<\/span><\/p>\n

              Integrity: <\/span><\/strong>This parameter measures how high the source code quality is when it is passed on to the QA.<\/span><\/p>\n

              Usability: <\/span><\/strong>This is tested in usability testing. This parameter means how easily usable the system is from the user’s perspective.<\/span><\/p>\n

              Flexibility: <\/span><\/strong>This parameter means how well the system can respond to uncertainty in a way that allows it to function normally.\u00a0<\/span><\/p>\n

              Scalability: <\/span><\/strong>This parameter is tested during scalability testing. This parameter measures the degree to which the application can scale up or scale out its processing capacity to meet an increase in demand.<\/span><\/p>\n

              Reusability: <\/span><\/strong>This means how many existing assets can be reused in some form within the software product development process or in another application.\u00a0<\/span><\/p>\n

              Interoperability: <\/span><\/strong>This parameter is tested during the Interoperability testing. This checks that the application interfaces properly with its components or other application or software.\u00a0<\/span><\/p>\n

              Portability: <\/span><\/strong>This parameter checks the ease with which the software can be moved from one environment to another.<\/span><\/p>\n

              Why Non-Functional Testing Is Essential<\/span><\/strong><\/h2>\n

              Why Non-Functional Testing Is Essential.<\/span><\/h3>\n

              Ensures Performance.<\/span><\/strong><\/h3>\n

              User can get frustrated with apps that work, but operate slowly.Non-functional testing makes sure the system responds quickly and behaves nicely under load.<\/span><\/p>\n

              Improves User Experience.<\/span><\/strong><\/h3>\n

              The usability test ensures the system is easy to use, navigate, and access.\u00a0 Useful for the general user and users with disabilities.<\/span><\/p>\n

              Ensures Reliability and Stability.<\/span><\/strong><\/h3>\n

              The software should perform consistently over long periods and under stress. Uptime, recovery and robustness are verified via Non-functional testing.<\/span><\/p>\n

              Ensures Scalability.<\/span><\/strong><\/h3>\n

              As a business grows, the number of users increases.Non-functional tests validate that the system can scale.<\/span><\/p>\n

              Identifies Bottlenecks Early.<\/span><\/strong><\/h3>\n

              If you detect memory leaks, slow DB queries, poor server configurations, etc., you save time and money.<\/span><\/p>\n

              Protects User Data.<\/span><\/strong><\/h3>\n

              Security testing helps avoid hacking, data theft, unauthorized access, vulnerabilities.<\/span><\/p>\n

              Ensures Compliance.<\/span><\/strong><\/h3>\n

              Different sectors need to be compliant with various standards such as WCAG, ISO, or GDPR. These standards may refer to accessibility, security, performance, etc.<\/span><\/p>\n

              Improves product quality and competitiveness.<\/span><\/strong><\/h3>\n

              A product is more reliable, professional and provides greater satisfaction thanks to high-quality non-functional attributes.<\/span><\/p>\n

              \"Visual<\/p>\n

              Benefits of Non-Functional Testing.<\/span><\/strong><\/h2>\n

              The Non-Functional testing advantages that improve software quality and user satisfaction.<\/span><\/strong><\/h3>\n

              In the non-functional testing, performance of the system is checked and also the performance bottlenecks which can affect the performance. The non-functional tests are less time-consuming compared to other test types.<\/span><\/p>\n

              Limitations of Non-functional Testing<\/span><\/strong><\/h3>\n

              Here are the Non-functional testing dis-advantages:<\/span><\/p>\n

                \n
              • Non-functional tests are performed repeatedly: <\/span><\/strong>Whenever there is a change in the application, non-functional testing is performed again. Thus, it is more resource intensive.<\/span><\/li>\n<\/ul>\n
                  \n
                • Expensive in case of software update: <\/span><\/strong>In case of software update, non-functional testing is performed again thus incurring extra charges to re-examine the software, and thus software becomes expensive.<\/span><\/li>\n<\/ul>\n

                  \u00a0Process of Non-Functional Testing<\/span><\/strong><\/h2>\n

                  Non-functional testing follows a structured process to ensure the software meets quality standards related to performance, scalability, usability, security, compatibility, and reliability.
                  \nBelow is the complete workflow, explained in depth.\u00a0<\/span><\/p>\n

                  Identify Non-Functional Requirements (NFRs).<\/span><\/strong><\/h3>\n

                  This is the foundation of the entire testing process.<\/span><\/p>\n

                  What Happens in This Step?<\/span><\/p>\n

                    \n
                  • Gather the quality expectations from the client, business team and stakeholders.<\/span><\/li>\n
                  • It is important to identify performance requirements like (page load in under 3 seconds, handles 50k users).<\/span><\/li>\n
                  • Document what security measures you expect to have in place (i.e., encryption type role-based access).<\/span><\/li>\n
                  • Record down requires for usability, accessibility, reliability, recovery, and compatibility.<\/span><\/li>\n<\/ul>\n

                    \"Process<\/h2>\n

                    Types of Non-Functional Testing<\/span><\/strong><\/h2>\n

                    \u00a0Below are the main categories:<\/span><\/p>\n

                    Performance Testing<\/span><\/strong><\/h2>\n

                    Below are the main categories.<\/span><\/p>\n

                    Load<\/span><\/strong> testing<\/span><\/strong> – is the act of putting demand on a structure or system and measuring its response.<\/span><\/p>\n

                    Stress<\/span><\/strong> testing<\/span><\/strong> -monitors the system when pushed beyond normal operation and checks for failure points. It identifies the points of failure, stability issues, and recovery. A system does not crash when extreme load is applied.<\/span><\/p>\n

                    Spike<\/span><\/strong> testing<\/span><\/strong> \u2013 checks how well the system may function when there is a sudden increase in the user load. It assesses the speed of spiking and the speed of stabilization of an applicationIt ensures the system can accommodate unexpected spikes in traffic.<\/span><\/p>\n

                    Scalability<\/span><\/strong> Testing<\/span><\/strong> \u2013 checks for the growth of the system with an increase in user demand. It assumes that system performance is assessed when resources or users are gradually added.We want to make sure the app can scale easily, without a drop in performance.<\/span><\/p>\n

                    Volume<\/span><\/strong> testing<\/span><\/strong> \u2013 checks whether the system can work with a really huge volume of data.Identifying problems like slow queries, memory overload and storage bottlenecks.This guarantees that the system can process huge datasets error-free.<\/span><\/p>\n

                    \u00a0<\/span>Security Testing<\/span><\/strong><\/h3>\n

                    Ensures the application is protected from threats and vulnerabilities.<\/span><\/p>\n

                    Includes:<\/span><\/strong><\/h3>\n

                    Vulnerability Scanning.<\/span><\/strong><\/h3>\n

                    The process of vulnerability scanning involves the use of automated tools for identifying weaknesses of a security system. It detects obsolete software, misconfigurations, and known vulnerabilities. The goal is to find issues before attackers exploit them.<\/span><\/p>\n

                    Penetration Testing.<\/span><\/strong><\/h3>\n

                    Penetration Testing Mimics Real World Attacks To Exploit Vulnerabilities. Ethical hackers test the system manually for vulnerabilities and weaknesses. It indicates the degree to which an attacker can destabilize a system and the damage possible<\/span><\/p>\n

                    \u00a0Authentication Testing.<\/span><\/strong><\/h2>\n

                    Authentication testing verifies the correctness of user identity. It tests the methods of login, password rules, OTP, biometric, session handling, etc. We want to ensure that no one gets unauthorized access.<\/span><\/p>\n

                    \u00a0Authorization Testing.<\/span><\/strong><\/h3>\n

                    Users are permitted to access only what they are authorized to. It verifies access, privileges, and constrictions enforced on resources as per the role. This prevents privilege escalation and data leakage.<\/span><\/p>\n

                    SQL Injection\/XSS Testing.<\/span><\/strong><\/h3>\n

                    These tests find security weaknesses that allow attacks to give hackers access to confidential information. SQL injection is an attack against the database while XSS is an attack against the web interface. All input field are validated and protected.<\/span><\/p>\n

                    \u00a0<\/span>Risk Assessment<\/span><\/strong><\/h3>\n

                    Risk assessment analyzes threats, their impact, and the likelihood of exploitation.
                    \nIt prioritizes vulnerabilities based on severity and business damage.
                    \nThis helps organizations focus on fixing high-risk issues first.<\/span><\/p>\n

                    \u00a0<\/span>Usability Testing<\/span><\/strong><\/h3>\n

                    Checks how simple and intuitive the software is.<\/span><\/p>\n

                    Includes:<\/span><\/strong><\/p>\n

                    Navigation Testing<\/span><\/strong><\/h3>\n

                    Navigation testing checks how easily users can move through the application.
                    \nIt ensures menus, buttons, and links lead to the right places without confusion.
                    \nThe goal is smooth, intuitive movement across screens and features.<\/span><\/p>\n

                    \u00a0<\/span>Accessibility Reviews<\/span><\/strong><\/h3>\n

                    Accessibility reviews ensure the software is usable by people with disabilities.
                    \nThey check screen readers, color contrast, keyboard navigation, and WCAG compliance.
                    \nThe aim is to make the app inclusive for all users.<\/span><\/p>\n

                    User Journeys<\/span><\/strong><\/h3>\n

                    User journey testing evaluates the end-to-end flow a user takes to complete tasks.
                    \nIt checks clarity, ease, and obstacles in processes like signup or checkout.
                    \nThe goal is to ensure a seamless, frustration-free experience.<\/span><\/p>\n

                    UI Clarity Checks<\/span><\/strong><\/h3>\n

                    UI clarity checks evaluate how clear, clean, and understandable the interface looks.
                    \nIt focuses on layout, readability, icons, spacing, and visual hierarchy.
                    \nThe aim is to make the app visually easy to understand and use.<\/span><\/p>\n

                    Reliability Testing<\/span><\/strong><\/h3>\n

                    Ensures the software runs without failure for a specified time.<\/span><\/p>\n

                    Includes:<\/span><\/strong><\/p>\n

                    Failover Testing<\/span><\/strong><\/h3>\n

                    Failover testing checks if the system automatically switches to a backup when the main system fails.
                    \nIt ensures continuity without data loss or downtime.
                    \nThe goal is uninterrupted service during server or component failures.<\/span><\/p>\n

                    Recovery Testing<\/span><\/strong><\/h3>\n

                    Recovery testing verifies how well the system can bounce back after a crash or failure.
                    \nIt examines data restoration, restart processes, and downtime.
                    \nThe goal is quick, safe recovery without corruption.<\/span><\/p>\n

                    Stability Testing<\/span><\/strong><\/h3>\n

                    Stability testing checks how the system behaves over long periods under normal load.
                    \nIt looks for memory leaks, crashes, and performance drops.
                    \nThe aim is reliable long-term operation.<\/span><\/p>\n

                    Consistency Checks<\/span><\/strong><\/h3>\n

                    Consistency checks ensure the system produces the same results every time under the same conditions.
                    \nIt verifies predictable behavior, especially for critical logic.
                    \nThis helps maintain user trust and system accuracy.<\/span><\/p>\n

                    Compatibility Testing<\/span><\/strong><\/h3>\n

                    Checks the software on different environments.<\/span><\/p>\n

                    Includes:<\/span><\/strong><\/p>\n

                    Browser Compatibility<\/span><\/strong><\/p>\n

                    This testing ensures the application works consistently across different browsers.
                    \nIt checks layout, functionality, and rendering.
                    \nThe goal is uniform user experience everywhere.<\/span><\/p>\n

                    Device Compatibility<\/span><\/strong><\/p>\n

                    Device compatibility testing verifies the app on various devices like mobiles, tablets, and desktops.
                    \nIt tests screen sizes, resolutions, and hardware differences.
                    \nThe aim is smooth performance across all devices.<\/span><\/p>\n

                    \u00a0OS Compatibility<\/span><\/strong><\/p>\n

                    OS compatibility testing checks if the software works correctly on different operating systems (Windows, iOS, Android, Linux).
                    \nIt verifies functionality, appearance, and behavior.
                    \nThe goal is platform-wide consistency.<\/span><\/p>\n

                    Network Compatibility<\/span><\/strong><\/p>\n

                    This evaluates the app under different network conditions like 2G, 4G, Wi-Fi, and low bandwidth.
                    \nIt measures speed, retries, and error handling.
                    \nThe aim is reliable performance regardless of network quality.<\/span><\/p>\n

                    Scalability Testing<\/span><\/strong><\/h3>\n

                    Scalability testing checks how well a system handles increasing workloads, users, or data.
                    \nIt measures performance when resources or demand gradually grow.
                    \nThe goal is to ensure the application scales smoothly without slowdowns or failures.<\/span><\/p>\n

                    Maintainability Testing<\/span><\/strong><\/h3>\n

                    Maintainability testing checks how easy it is to modify, update, or fix the software.
                    \nIt evaluates code quality, documentation, modularity, and debugging effort.
                    \nThe goal is to ensure quick, low-cost maintenance throughout the software\u2019s life.<\/span><\/p>\n

                    Portability Testing<\/span><\/strong><\/h3>\n

                    Portability testing checks how easily a software application can be moved between different environments or platforms.
                    \nIt evaluates installation, adaptability, compatibility, and migration effort.
                    \nThe goal is to ensure the software works smoothly across multiple systems with minimal changes.<\/span><\/p>\n

                    \"Grid<\/h2>\n

                    Examples of Non-Functional Testing:<\/span><\/strong><\/h2>\n

                    Example 1: E-commerce Website Sale Event<\/span><\/strong><\/h3>\n

                    Imagine an online store preparing for a significant sale, such as Black Friday or Diwali.<\/span><\/p>\n

                    Load\/Stress\/Spike Testing: You simulate the arrival of 200,000 or more visitors at once, and can even push it up to 500,000 sudden users to see how the system reacts regarding response time, errors, and crashing.<\/span><\/p>\n

                    Security Testing of Checkout: You test that the checkout process is secure, for instance, PCI compliance, encryption, no data leakage.\u00a0<\/span><\/p>\n

                    Usability & Compatibility Testing: In the rush, you also check that pages load fast, mobile users on varying devices aren’t blocked, and the user experience remains smooth.<\/span><\/p>\n

                    Why it matters: If the site fails under load, checkout breaks, or the user experience suffers, then you lose huge revenue and customer trust. Online-retail testing guides confirm this need.<\/span><\/p>\n

                    Example 2: Banking App<\/span><\/strong><\/h3>\n

                    Consider a mobile banking application used by many customers for transactions, transfers, bill payments, etc.<\/span><\/p>\n

                    Performance & Reliability: The application should ensure swift responses under a heavy transaction load where many users are performing concurrent fund transfers without crashes or delays.<\/span><\/p>\n

                    Security Testing: Strong data encryption, secure authentication, and authorization so that no unauthorized access or data breaches come about.<\/span><\/p>\n

                    Usability & Accessibility: Above all, the interface has to be simple, clear, and intuitive, especially for users who are not tech-savvy-for example, older users.<\/span><\/p>\n

                    Why it matters: In a banking context, failure in any of these non-functional aspects could mean financial loss, regulatory issues, reputational damage.<\/span><\/p>\n

                    \u00a0<\/span>Example 3: Video Streaming App<\/span><\/strong><\/h3>\n

                    Consider a streaming service such as Netflix or similar, with numerous users watching video at different times.<\/span><\/p>\n

                    Buffering & Latency Testing: Testing how video loads\/streams when network bandwidth is weak, how frequently buffering occurs, and how fast quality adjusts.<\/span><\/p>\n

                    Server Load & Scalability: At peak times, for example, evening or weekend events-many users stream simultaneously. Test that the backend scales and the system remains stable for 24+ hours.<\/span><\/p>\n

                    Usability & Compatibility: The UI must be smooth on different devices – TVs, mobiles, tablets; adaptive streaming should work, UI must be consistent.<\/span><\/p>\n

                    Why it Matters: Poor streaming experience-buffering, quality drop, app crashes-lead to users quitting, which reduces retention and revenue.<\/span><\/p>\n

                    \u00a0<\/span>Example 4: Ride-Sharing App<\/span><\/strong><\/h3>\n

                    Think of an Uber-like or Ola Cabs-like ride-sharing platform where a passenger requests a ride and the drivers respond.<\/span><\/p>\n

                    Performance & Reliability: The application needs to quickly find the drivers, respond to ride requests, and handle multiple riders and drivers all at once with minimal delay.<\/span><\/p>\n

                    GPS & Device\/Network Compatibility Testing: Check that GPS accuracy remains good, the app works under variable network conditions, on many devices, and does not fail when there is a spike in riders.<\/span><\/p>\n

                    Security & Usability: All data, whether payment or personal data, must be secure, the UI accessible to all users regardless of their experience with apps, and the process easy.<\/span><\/p>\n

                    Why it matters: If the app is slow, inaccurate, insecure or difficult to use, users will abandon it for competitors. Also, safety is a concern with ride apps.<\/span><\/p>\n

                    \"Infographic\u00a0<\/span><\/h2>\n

                    FAQ\u2019s<\/span><\/strong><\/h2>\n

                    What is an example of non-functional?<\/span><\/strong><\/p>\n

                    It involves, for instance, testing how quickly a web page downloads when a website experiences heavy traffic. It focuses on performance, usability, security, or reliability rather than features.<\/span><\/p>\n

                    What is NFT in testing?<\/span><\/strong><\/p>\n

                    NFT stands for Non-Functional Testing. It tests the quality attributes of the software such as speed, security, etc. It assesses how well the system performs, rather than what it does.<\/span><\/p>\n

                    What is functional vs. non-functional?<\/span><\/strong><\/p>\n

                    Functional testing checks what the system does\u2014features, actions, and behavior.<\/span><\/p>\n

                    Non-functional testing checks how well it works: performance, speed, usability, and security.<\/span><\/p>\n

                    What are the four types of software tests?<\/span><\/strong><\/p>\n

                    These generally include Functional Testing, Non-Functional Testing, Maintenance Testing, and Performance Testing. These cover both feature validation and system quality checks.<\/span><\/p>\n

                    What is functional non-functional testing in software testing?<\/span><\/strong><\/p>\n

                    Functional testing validates system features based on requirements. Non-functional testing validates system qualities such as performance, reliability, and usability.<\/span><\/p>\n

                    What is the difference between functional and non-functional software testing?<\/span><\/strong><\/p>\n

                    Functional testing checks the correctness of features through inputs and outputs. It checks the system attributes like speed, capacity, security, and the experience of the user.<\/span><\/p>\n

                    What is an example of functional and non-functional testing?<\/span><\/strong><\/p>\n

                    Functional example: To test whether the button successfully logs in users. Non-functional example: This would test how quickly the login page loads with 1,00,000 users.<\/span><\/p>\n

                    What is the purpose of non-functional testing?<\/span><\/strong><\/p>\n

                    It aims to make the system fast, secure, scalable, stable, and user-friendly. It improves real-world performance and overall software quality.<\/span><\/p>\n

                    What is non-functional testing in software testing?<\/span><\/strong><\/p>\n

                    Non-functional testing concerns verification of software’s quality attributes, such as performance, security, usability, and reliability. It checks how the system will behave efficiently under real conditions.<\/span><\/p>\n

                    \u00a0Conclusion<\/span><\/strong><\/h2>\n

                    NFT is very important to ensure that not only does the software work correctly, but it also works reliably and securely in real-life conditions. With this, it will make sure that the users get a high-quality experience and long-term system success, validating its speed, scalability, usability, security, and stability. In today\u2019s competitive digital world, this is no longer an add-on but an essential step towards moulding functional software into a truly dependable and use-centered product.<\/span><\/p>\n

                    It helps organizations predict bottlenecks before users face them, reduces costly failures, and builds trust in their applications.<\/span><\/p>\n

                    Properly planned, with the right tooling, and continuously monitored, non-functional testing can be a very powerful component of software testing.<\/span><\/p>\n

                    Most importantly, it ensures your product will deliver not only functionality but also long-lasting value and performance.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                    What Is Non Functional Testing In Software Testing Non-functional testing assesses the effectiveness of the other elements of a software application. It emphasised speed, security, usability, and scalability under various conditions with examples. Non-functional testing provides insights into how well a system performs in a specified environment and after subjecting it to various constraints. Usage […]<\/p>\n","protected":false},"author":1,"featured_media":26601,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[8],"tags":[],"class_list":["post-26598","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-development"],"acf":[],"_links":{"self":[{"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/posts\/26598","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/comments?post=26598"}],"version-history":[{"count":0,"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/posts\/26598\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/"}],"wp:attachment":[{"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/media?parent=26598"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/categories?post=26598"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/stg.tftus.com\/blogs\/wp-json\/wp\/v2\/tags?post=26598"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}