<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[TrackIt - Medium]]></title>
        <description><![CDATA[TrackIt AWS DevOps Engineering Blog - Medium]]></description>
        <link>https://medium.com/trackit?source=rss----d39762e03b65---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>TrackIt - Medium</title>
            <link>https://medium.com/trackit?source=rss----d39762e03b65---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:00:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/trackit" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Everything Is AI Now. What Does That Mean for Design?]]></title>
            <link>https://medium.com/trackit/everything-is-ai-now-what-does-that-mean-for-design-25dfa5dbe966?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/25dfa5dbe966</guid>
            <category><![CDATA[design-thinking]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Isabela Teodoro]]></dc:creator>
            <pubDate>Wed, 13 May 2026 17:19:18 GMT</pubDate>
            <atom:updated>2026-05-13T17:19:17.397Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Written &amp; Illustrated by Isabela Teodoro and Paula Soares, UX/UI Designers at TrackIt.</em></p><h3><strong>How AI is Changing the Way We Work</strong></h3><p>AI was largely viewed as an enabling technology in the late 2010s, widely promoted for its ability to process data, build analytical solutions, predict outcomes, and detect potential errors before they occurred. Despite the progress already being made at the time, it would have been difficult to imagine the speed at which LLMs and GenAI would become part of our everyday lives, shaping how we communicate and interact both digitally and socially.</p><p>AI is no longer something we simply use when needed. It is becoming embedded in the way we work, communicate, and consume information online. While concerns about AI replacing jobs have not disappeared, a different kind of anxiety is also beginning to emerge: the fear of falling behind, of not understanding or using AI in a world where it is becoming part of virtually everything, including tasks once considered too ordinary to require technology.</p><p>As we navigate a period where everything seems to revolve around AI, it may be worth taking a step back to examine what has actually changed. This applies not only to our daily routines, but also to the way we approach work across technology and innovation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cCN0WqyZjS_OLtZUrH8A1g.jpeg" /><figcaption><em>Abundance of access doesn’t guarantee clarity of thought.</em></figcaption></figure><p>At this point, pretending AI does not exist or rejecting it entirely is no longer realistic, despite the many concerns surrounding how it is being used. Like any technology, AI was created to simplify human activities, make everyday tasks more efficient, and allow people to dedicate more time to what truly matters. And perhaps that is precisely where the focus should remain.</p><p>In the field of design, as well as across other creative disciplines, AI can be seen as a double-edged sword. On one hand, it is important to exercise discernment when deciding how and why AI should be incorporated into creative and design processes. On the other hand, its ability to support research, analyze large volumes of information, and synthesize data can significantly improve the immersion phase of a project. Tasks that once required hours of manual review, organization, and interpretation can now be accelerated through AI-assisted workflows, allowing teams to focus more deeply on decision-making, strategy, and creative direction.</p><h3><strong>The New Routine for Designers: AI as a Creative Aid</strong></h3><p>“Creative block” is a recurring concept in design and other creative disciplines, often defined as the inability to move forward with an idea, develop a concept, or continue a creative process. What has changed in recent years, however, is the way many creative professionals now respond to that moment of stagnation. With the growing presence of AI in creative workflows, artificial intelligence has increasingly taken on the role of a kind of collaborator: a constant source of suggestions, references, and alternative directions. And it is precisely within this dynamic that both the value and the risks of AI begin to surface.</p><p>Before AI, periods of creative block often forced people to slow down, seek references, explore new approaches, and engage with different processes and perspectives. In a sense, the absence of immediate ideas sparked deeper reflection, making room for those brilliant insights that arise out of nowhere during ordinary activities, like in the shower, on a walk, or in any situation where the mind is not focused on intentional problem-solving. In cognitive psychology, this is often associated with diffuse thinking: a mental state in which the mind, once relaxed, begins connecting information in non-linear and often creative ways.</p><p>As the need to move through this “eureka” stage diminishes, the creative process itself begins to change. The results no longer emerge solely from personal reflection or individual inspiration, but from algorithms designed to process large volumes of information and generate suggestions based on behavioral patterns and previous inputs. In this dynamic, creative thinking risks becoming less connected to introspection, experimentation, and moments of emptiness, and more dependent on the rapid customization of ready-made outputs.</p><p>Indeed, having an agent that assists with more demanding processes can be a significant advantage. However, replacing original thinking with ideas generated by a machine risks producing excessively standardized results. After all, another person with a similar profile could run the same prompt and arrive at nearly identical outputs, reducing the originality that emerges from individual experiences, personal contradictions, and the uniquely human way of interpreting the world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WIUsm0nVZSIp2td4uMCRiQ.jpeg" /><figcaption><em>AI works better as a partner, not a replacement.</em></figcaption></figure><p>Trying, failing, reworking, and finishing are all part of the creative process, and each of these stages shapes perception, imagination, and creative identity over time. Creativity rarely emerges from environments driven entirely by speed, standardization, and constant optimization. More often, it requires time, reflection, and space for ideas to mature.</p><h3>The Impacts of Using AI Without a Clear Objective</h3><p>Have you ever picked up your phone to do something, only to get distracted by a notification, open an app, remember an unanswered message, switch to another app, notice a pending purchase, and suddenly realize that an hour has passed without completing the original task? Or worse, without even remembering what that original task was? This feeling of having attention constantly redirected by digital platforms reflects the way algorithms shape behavior, influence interests, and gradually push people toward patterns of passive consumption.</p><p>Using AI in the workplace without a clear objective can unfold in much the same way. A task begins with the intention of using AI as support, but without a defined direction, clear expectations, or a strong sense of what quality should look like in the final result, the process can quickly become driven almost entirely by automated suggestions. At first, everything appears efficient: the work moves faster, decisions feel easier, and the project progresses with minimal friction. However, when AI-generated suggestions begin replacing critical thinking rather than supporting it, the final result can easily drift toward solutions that feel generic, predictable, or lacking in depth.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WYaD9n5iTxf5YKK73mt03Q.jpeg" /><figcaption>Speed without intention produces outlines, not solutions</figcaption></figure><p>Interface patterns exist for a reason. Following guides, standards, and behaviors defined in libraries is not what makes a solution superficial; the difference lies in how those elements are used. When AI is applied without a clear objective or design intention, the process can gradually become a sequence of automatic approvals, where each accepted suggestion pushes the result toward increasingly generic territory. The final product starts to resemble the digital equivalent of an off-the-shelf item: efficient, standardized, and quick to produce, but lacking the characteristics that make creative work memorable or distinctive.</p><h3><strong>Designing With AI, Not Around It.</strong></h3><p>As AI becomes increasingly integrated into creative workflows, the role of designers is unlikely to disappear. What may change instead is <strong>the nature of creative work</strong> itself. Technical execution, organization, and production are increasingly being accelerated through AI-assisted processes, but interpretation, judgment, and creative direction still depend on human perspective.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JPooaxByo0FeTh1VIcq5WQ.jpeg" /><figcaption><em>Beyond the screen: AI can reshape how society works</em></figcaption></figure><p>The distinction between simply generating outputs and creating meaningful experiences may become more important. Access to AI can accelerate workflows, but it <strong>does not</strong> automatically <strong>replace</strong> the ability to interpret context, understand people, or make intentional creative decisions. In many ways, these qualities may become even more valuable as creative processes continue evolving alongside AI.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=25dfa5dbe966" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/everything-is-ai-now-what-does-that-mean-for-design-25dfa5dbe966">Everything Is AI Now. What Does That Mean for Design?</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Migrating a Legacy SQL Server Application to Amazon RDS in 4 Weeks with MCP Servers]]></title>
            <link>https://medium.com/trackit/migrating-a-legacy-sql-server-application-to-amazon-rds-in-4-weeks-with-mcp-servers-4d025155f28d?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/4d025155f28d</guid>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[database]]></category>
            <dc:creator><![CDATA[Nathan de Balthasar]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 08:37:01 GMT</pubDate>
            <atom:updated>2026-04-15T08:49:08.960Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oK6vBggUVWKTYQD1QB3I8Q.png" /></figure><h3><strong>The Challenge: Migrating a Legacy System to Amazon RDS</strong></h3><p>A business-critical management system was running on SQL Server 2008 R2 on EC2, with more than 1,500 stored procedures and a codebase partially reconstructed from decompiled binaries. The objective was to migrate to <a href="https://aws.amazon.com/rds/">Amazon Relational Database Service (Amazon RDS)</a> for SQL Server 2022 while maintaining full functional parity.</p><p>RDS does not support several legacy capabilities, including xp_cmdshell, direct file system access, and network shares. These constraints required both code refactoring and architectural changes.</p><p>A traditional migration would typically span several months. This article outlines how TrackIt used the <a href="https://docs.aws.amazon.com/SchemaConversionTool/latest/userguide/CHAP_Welcome.html">AWS Schema Conversion Tool (SCT)</a>, <a href="https://aws.amazon.com/dms/">Database Migration Service (DMS)</a>, and <a href="https://claude.ai/login">Claude</a> with <a href="https://modelcontextprotocol.io/docs/getting-started/intro">Model Context Protocol (MCP)</a> to structure the work. It also examines where this approach reduced effort, where engineering judgment remained essential, and what could be improved in future migrations.</p><h3>The Migration Toolkit: SCT, DMS, and MCP</h3><h4>1. AWS Schema Conversion Tool</h4><p>AWS Schema Conversion Tool (SCT) analyzed the source database and generated assessment reports highlighting compatibility issues. It automated the conversion of 99.3% of code objects and produced a prioritized list for the remaining 0.7%.</p><p><strong>Key finding:</strong> Of roughly 1,500 stored procedures, only about one third were actively used by the application. SCT made it possible to focus effort on what was actually relevant, rather than treating the entire codebase as in scope.</p><h4>2. AWS Database Migration Service</h4><p>AWS Database Migration Service (DMS) handled the bulk data transfer from source to target. One constraint became apparent early: the database configuration did not support Change Data Capture (CDC), which DMS typically relies on for continuous replication and near zero downtime cutovers.</p><p>Without CDC, it was not possible to keep the target synchronized with live writes during migration. The approach instead relied on taking a snapshot of the production EC2-hosted SQL Server, restoring it to Amazon RDS, and performing the cutover during a scheduled maintenance window. The system was taken offline over a weekend, allowing time to complete the migration, validate the target, and update connection strings before business hours resumed.</p><p>This approach was effective, but it introduces a constraint that is often understated. When CDC is not supported, a maintenance window is required. It should be planned explicitly rather than assumed away.</p><h4>3. Model Context Protocol + Claude</h4><p>Model Context Protocol (MCP) provided Claude with read access to both the source and target databases simultaneously. This addressed a recurring issue in database migrations: repeated context switching between environments.</p><p>Without an MCP server, comparing a stored procedure required querying each database separately, copying results, and manually diffing them. With MCP, both definitions could be queried within a single prompt, and the differences returned in a structured format.</p><p>This reduced mechanical overhead but did not replace engineering judgment. Claude highlighted discrepancies, but decisions on how to resolve them remained with the engineering team.</p><p>In practice, the MCP server enabled:</p><ul><li>Cross-referencing SCT findings against live procedure definitions without manual copying</li><li>Checking execution statistics before deciding whether to refactor or exclude a procedure</li><li>Validating generated SQL against the target schema prior to deployment</li></ul><p>All generated code was reviewed and tested by an engineer before being executed in staging or production.</p><h3>Securing Database Access with Least Privilege</h3><p>Before getting into the implementation, one question needs to be addressed upfront: how can an AI assistant be given access to two production databases without introducing a security risk?</p><p>The answer follows a standard principle. Access should be limited strictly to what the task requires, nothing more. This was defined before writing any prompts, not treated as a cleanup step afterward.</p><h4>MCP credential permissions</h4><p>Both connections were configured as read-only, scoped strictly to schema metadata:</p><p>• SELECT on schema metadata (INFORMATION_SCHEMA, sys.* views)</p><p>• SELECT on stored procedure definitions (OBJECT_DEFINITION, sys.sql_modules)</p><p>• SELECT on execution stats (sys.dm_exec_procedure_stats)</p><p>• SELECT on the migration queue table</p><h4>Restricted operations</h4><p>• No INSERT, UPDATE, or DELETE on any application table</p><p>• No DROP, ALTER, or CREATE on any object</p><p>• No access to application user data — only schema and metadata</p><p>• No cross-database access beyond the two migration databases</p><p>Claude could inspect, compare, and analyze, but any change followed a standard deployment process. The LLM proposed SQL changes, which were reviewed and validated by an engineer before being executed in the target environment.</p><h4>Separate credentials for source and target</h4><p>Each database connection used a separate service account, scoped to its specific role. The source account had read access to schema metadata and execution statistics. The target account had read access to schema information only and no access to application data, which had not yet been migrated during the analysis phase.</p><p>This separation limited the blast radius of any compromised credential to a single database with read-only access.</p><p>The practical rule was straightforward: scope credentials to the task, verify that no broader permissions exist, and treat MCP access the same as any external integration. With read-only, schema-scoped access, the worst-case outcome is an unexpected query. Granting write access to production data introduces a different level of risk and should require an explicit decision.</p><h3>Phase 1: Assessment with SCT</h3><p>Running AWS Schema Conversion Tool (SCT) against the source database showed that roughly 1,400 storage objects converted automatically. Of approximately 1,800 code objects, 99.3% converted without intervention. The remaining 0.7% required manual attention, all related to xp_cmdshell and file system operations that have no direct equivalent in Amazon RDS.</p><p>Amazon RDS does not support xp_cmdshell for operating system command execution, direct file system access, network share mounts, or BULK INSERT from file paths.</p><p>Six stored procedures relied on these features, but only one was actively used by the application. That procedure also depended on other procedures that required refactoring. This is where allowing Claude to query the database proved useful.</p><h4>Working Without Documentation</h4><p>The codebase had no meaningful documentation. The application had been running for fifteen years, the original developers were no longer available, and what remained was a set of decompiled DLLs (compiled application binaries) and a live database. There was no specification to consult, no runbook describing job execution, and no record explaining past design decisions.</p><h4>Querying the System Directly</h4><p>MCP proved particularly useful in this context. With read access to procedure definitions and execution statistics, Claude could answer questions directly against the live database rather than relying on code alone. A typical prompt was: “What does this procedure do, and is it still being called?” Claude retrieved the definition, checked execution history, and traced dependencies, returning a structured summary of its purpose, callers, and last execution time.</p><p>This approach relied on observable data rather than inference. Execution counts, last run times, and dependency chains provided a factual basis. Claude synthesized that data into summaries, which were then validated against known business logic. The combination of database-derived information and engineering context proved more reliable than either alone.</p><p>It also helped clarify naming. Years of accumulated conventions had resulted in procedures with unclear or inconsistent prefixes. By correlating definitions, call graphs, and execution frequency, it became possible to categorize them without tracing each one through the decompiled application code.</p><p>In the absence of documentation, the database itself became the primary source of truth. Access to execution statistics, dependency graphs, and schema metadata within the same workflow reduced ambiguity and made the migration more tractable.</p><h3>Phase 2: Querying Both Databases with an MCP Server</h3><p>The source system relied on several EC2-specific capabilities with no direct equivalents in Amazon RDS. These included xp_cmdshell for file operations, network file shares for batch input, and file path-based BULK INSERT. The target required RDS-native alternatives: Amazon S3 for file storage, rds_restore_database for backup and restore, and SqlBulkCopy with in-memory streams for bulk data loading.</p><p>Of approximately 1,500 stored procedures, roughly 500 were active and in scope for migration.</p><p>With an MCP server configured for both databases, Claude could compare procedure definitions across source and target within a single prompt. For example, when analyzing a procedure that used BULK INSERT from a file path, Claude identified the dependency on direct file system access and the absence of an equivalent in the target environment. It then suggested refactoring to an in-memory approach.</p><p>This aligned with what AWS Schema Conversion Tool (SCT) had already flagged. The difference was that, with full procedure context available, Claude could generate a targeted replacement rather than a generic recommendation.</p><h3>Real-World Example: The Import Wizard Problem</h3><p>One of the most critical features allowed users to upload CSV files for bulk processing. The existing implementation saved the uploaded file to disk and used BULK INSERT with a file path. Neither approach is supported in Amazon RDS, which has no access to local or network file systems.</p><h4>How SCT + MCP + Claude Addressed the Issue</h4><p>AWS Schema Conversion Tool (SCT) first flagged the incompatibility. Claude then used the MCP server to pull the full context, including the target table structure, the source procedure definition, and the RDS environment, to determine the required changes.</p><p>The replacement pattern was well established. The uploaded file is handled in memory as a stream rather than written to disk, parsed in memory, and loaded into the staging table using <strong>SqlBulkCopy</strong>. The MCP server added a critical layer by allowing Claude to verify the target table schema against the generated column mappings, avoiding boilerplate code that would otherwise require manual adjustment.</p><p>The output was reviewed, validated against the expected schema, and tested in a staging environment before deployment. The approach itself was not novel. The value came from reducing the iteration required to ensure that the generated code aligned with the live target schema.</p><h3>Batch Processing Challenge</h3><p>A nightly batch job processed data files from a network share using xp_cmdshell to scan directories and RESTORE DATABASE from file paths. This approach is not supported in Amazon RDS.</p><p>The replacement required a change in architecture, moving from a file share polling model to an Amazon S3-backed queue.</p><p>Incoming files are uploaded directly to Amazon S3 instead of a network share. A queue table tracks pending uploads. The processing procedure reads from this queue, invokes the RDS-native restore function using the S3 file reference, and marks each entry as processed. The scheduled job polls the queue table rather than scanning a directory.</p><p>The architectural shift from file share polling to queue-based processing was an engineering decision made before any implementation work began. The procedure that implements this was then drafted with Claude and reviewed and tested before deployment.</p><h3>Tightening the Feedback Loop</h3><p>The primary time savings in this workflow did not come from code generation. It came from reducing the gap between writing a fix and verifying that it was correct.</p><p>In a traditional workflow, the cycle is repetitive: make a change, deploy to a test environment, wait, test manually, identify issues, and repeat. Each cycle can take hours. With an MCP server, Claude could query the target schema before generating any changes. This meant that column mismatches and data type errors were identified before deployment rather than after. Business logic validation still took place in staging. What changed was the speed of identifying mechanical issues.</p><p>A concrete example illustrates this. A batch job was not picking up files from Amazon S3. Claude queried the queue table and identified that the pending rows contained a DataType value that did not match the procedure’s filter condition. This is the kind of issue a developer would typically find by running queries manually. The difference was that it was identified within the same workflow, without switching tools.</p><h4>Working Through SCT Reports</h4><p>AWS Schema Conversion Tool (SCT) generates detailed assessment reports. Reviewing these with Claude made it possible to cross-reference findings against live execution statistics without leaving the workflow. For example, when a procedure was flagged for using BACKUP or RESTORE commands, Claude retrieved its definition and checked execution frequency over the previous 30 days. The result was zero executions, so the procedure was excluded rather than refactored.</p><p>The workflow was straightforward. SCT identified the issue. Claude retrieved the relevant procedure definition and usage data through MCP servers. A decision was then made to refactor, replace, or exclude. If a replacement was required, Claude drafted it, and it was reviewed and deployed.</p><p>The decision-making remained with the engineering team. Claude provided the necessary data and context to make those decisions more efficiently.</p><h3>Measuring Impact</h3><p>The following estimates are approximate. The “traditional” column reflects what the same project would likely have taken using manual tooling and no AI assistance, based on comparable migrations completed previously.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/606/1*_c8he-0Xdr-7LL_F8_Uemw.png" /></figure><p>The time savings were real, but they came from specific areas. AWS Schema Conversion Tool (SCT) eliminated weeks of manual schema analysis. AWS Database Migration Service (DMS) handled the bulk data load from a production snapshot, removing the need for custom ETL scripts. Without CDC support, however, it could not eliminate the maintenance window entirely. Claude and MCP reduced iteration overhead on the edge-case procedures, particularly in drafting boilerplate and cross-checking schema alignment.</p><p>What did not change was the need to understand the business logic, make architectural decisions, write tests, and manage deployment. The four-week timeline reflects a focused team with clear requirements, not a shortcut around engineering discipline.</p><h3>Key Takeaways</h3><h4>1. SCT and DMS do the heavy lifting, but have clear limits</h4><p>SCT automated 99.3% of the schema conversion and provided a prioritized view of what required attention. DMS handled the bulk data load, eliminating the need for custom ETL scripts. Neither depends on AI; both are effective tools that are often underutilized. However, DMS does not always provide continuous replication. If the source database does not support Change Data Capture (CDC), the migration relies on a snapshot and requires a maintenance window. This constraint should be identified early.</p><h4>2. MCP is useful for eliminating context-switching, not for making decisions</h4><p>The primary productivity gain from MCP came from eliminating repeated context switching between tools. Querying both databases within a single workflow reduced manual comparison and kept the process focused. It did not replace engineering judgment.</p><h4>3. AI-generated code requires full review</h4><p>Every stored procedure drafted with Claude was reviewed against business logic, tested in staging, and validated against expected outputs before production use. AI-assisted code should be treated as draft output that requires the same level of scrutiny as any other implementation.</p><h4>4. Feedback loop improvements are meaningful but limited</h4><p>Validating schema alignment before deployment reduces iteration time and helps catch mechanical errors such as column mismatches or incorrect data types earlier in the process. It does not eliminate the need for thorough testing of business logic and edge cases.</p><h3>Getting Started with This Approach</h3><h4>Step 1: Run the SCT assessment</h4><p>Download the AWS Schema Conversion Tool (SCT), connect to the source database, and generate an assessment report. Review the compatibility results and focus on items that fall below the auto-conversion threshold.</p><h4>Step 2: Set up DMS and verify CDC support</h4><p>Before planning for continuous replication, confirm whether the source database supports Change Data Capture (CDC). If supported, DMS can keep the target in near real time sync, allowing a low-downtime cutover. If not, DMS will perform a snapshot-based load, and a maintenance window will be required.</p><p>Create a replication instance, configure source and target endpoints, and run a full load task. If CDC is supported, add a CDC task afterward. If not, plan the cutover window early to avoid last-minute constraints.</p><h4>Step 3: Configure MCP for both databases</h4><p>Use the SQL Server MCP server package to connect Claude to each database. Each connection should be defined separately, with its own endpoint and read-only credentials. The source connects to the EC2 instance, and the target connects to the Amazon RDS endpoint. Both should use scoped service accounts as defined earlier.</p><h4>Step 4: Use Claude</h4><p>With both connections active, Claude can query across both databases within a single prompt. Use it to compare procedure definitions, check execution statistics, cross-reference SCT findings against the live schema, and trace dependencies. Keep prompts specific. For example: “Compare this procedure between source and target” produces more useful results than open-ended queries.</p><h3>Conclusion</h3><p>This migration worked because each tool was used for a specific purpose, not because the combination was inherently transformative.</p><p>SCT provided automated assessment at scale, analyzing 1,500 procedures in hours and producing a clear list of what required human attention. DMS handled data replication without the need for custom scripting. Claude reduced the mechanical overhead of edge cases by drafting procedure replacements with schema context, cross-referencing reports against live data, and identifying mismatches before deployment.</p><p>None of these tools replaced architectural judgment. The decision to move from a file share polling model to an Amazon S3-backed queue was an engineering decision that required an understanding of the system. The AI accelerated implementation after that decision was made.</p><p>This pattern can be applied to other migrations, such as Oracle to Amazon RDS for PostgreSQL or MongoDB to Amazon DocumentDB, where incompatibilities are clearly defined. The prerequisite remains the same. The system must be understood well enough to validate the generated output. Without that, the tooling only increases the speed at which incorrect decisions are implemented.</p><h3>Resources</h3><ul><li><a href="https://aws.amazon.com/dms/schema-conversion-tool/">https://aws.amazon.com/dms/schema-conversion-tool/</a></li><li><a href="https://aws.amazon.com/dms/">https://aws.amazon.com/dms/</a></li><li><a href="https://aws.amazon.com/blogs/database/migrate-logins-database-roles-users-and-object-level-permissions-to-amazon-rds-for-sql-server-using-t-sql/">https://aws.amazon.com/blogs/database/migrate-logins-database-roles-users-and-object-level-permissions-to-amazon-rds-for-sql-server-using-t-sql/</a></li><li><a href="https://medium.com/@guillermo.wrba/moving-mission-critical-sql-server-workloads-effectively-to-cloud-with-aws-dms-4302f8c9ca89">https://medium.com/@guillermo.wrba/moving-mission-critical-sql-server-workloads-effectively-to-cloud-with-aws-dms-4302f8c9ca89</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d025155f28d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/migrating-a-legacy-sql-server-application-to-amazon-rds-in-4-weeks-with-mcp-servers-4d025155f28d">Migrating a Legacy SQL Server Application to Amazon RDS in 4 Weeks with MCP Servers</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Recovering a Lost ASP.NET Codebase Using Decompilers and LLMs]]></title>
            <link>https://medium.com/trackit/recovering-a-lost-asp-net-codebase-using-decompilers-and-llms-123142bca20c?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/123142bca20c</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[aspnet]]></category>
            <category><![CDATA[csharp]]></category>
            <dc:creator><![CDATA[Nathan de Balthasar]]></dc:creator>
            <pubDate>Wed, 01 Apr 2026 07:16:44 GMT</pubDate>
            <atom:updated>2026-04-01T07:23:29.291Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k8CfEnBLeW0ui_QNarpOBg.png" /></figure><h3>Overview</h3><p>TrackIt was recently contacted by a customer who had lost access to the source code of a critical internal ASP.NET Framework application, originally developed in the early 2000s and last updated around 2018. The application was still running in production and played a central role in daily operations, but without the source code the customer could no longer maintain it, fix issues, or implement new features. Restoring a functional and maintainable version of the codebase was essential for business continuity.</p><p>TrackIt fully recovered the customer’s production codebase by combining <a href="https://www.jetbrains.com/decompiler/">dotPeek</a>, a .NET decompiler, with LLM-assisted reconstruction, preserving consistency, readability, and long-term sustainability.</p><p>Although dotPeek can decompile binaries back into C#, the output often contains compiler artifacts, generic naming, and patterns that do not align with established engineering practices. In other words, it produces code that compiles, but not code that teams want to maintain.</p><p>Large Language Models (LLMs) helped refine, reorganize, and clarify the decompiled output, transforming raw reconstructed logic into a clean, coherent, and maintainable codebase.</p><h3>Decompiling .NET Source Code</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*RibciZ5Y4kv03moY.png" /><figcaption><strong><em>Source:</em></strong><em> </em><a href="https://www.jetbrains.com/decompiler/"><em>https://www.jetbrains.com/decompiler/</em></a></figcaption></figure><p>The first step in the recovery process was to extract information from the compiled binaries. Tools such as dotPeek, ILSpy, and Rider’s built-in decompiler are well suited for this task. They inspect the Intermediate Language (IL) contained in a .NET assembly and reconstruct an approximate C# representation.</p><p>This process restores a significant portion of the original application structure, including:</p><ul><li>Namespaces and class hierarchies</li><li>Method signatures and control flow</li><li>ASP.NET WebForms code-behind logic</li><li>MVC controllers, models, and data access layers (when applicable)</li><li>Configuration-dependent behavior embedded in compiled code</li></ul><p>In this case, dotPeek generated a functional codebase that could compile and run, providing a solid starting point for rebuilding the application.</p><p>However, the output also exposed clear limitations in what decompilation alone could recover.</p><h3>What Decompilers Do Not Restore</h3><p>Decompilers are limited to what the compiler preserves in the IL. Everything else is lost. As a result, the output often includes:</p><ul><li>Missing comments and documentation</li><li>Loss of meaningful variable names due to optimization</li><li>Redundant casts and unnecessary conversions</li><li>Unexpected Unicode escape sequences</li><li>Inconsistent formatting</li><li>Code that is difficult to follow for developers unfamiliar with the application</li></ul><p>The result is valid C#, but not production-ready code. Maintaining such a codebase would be costly and error-prone.</p><h3>Structural Gaps Caused by a Decade of Evolution</h3><p>The customer also had an older snapshot of the source code from around 2018, while the production binaries had evolved significantly. Over time, the application had accumulated:</p><ul><li>New features</li><li>Changes to business rules</li><li>Additional UI logic</li><li>Security changes</li><li>Integrations with other systems</li></ul><p>These differences could not be inferred from the old code alone. They had to be extracted and reconstructed from the binaries. LLMs played a key role in this process.</p><h3>Beyond Decompilation: Using LLMs to Rebuild Maintainable Code</h3><p>Once the raw decompiled source was available, the next step was to turn it into code that a development team could realistically maintain. This is where LLM-assisted reconstruction proved decisive.</p><p>We approached LLMs not as code generators, but as <strong>refinement tools</strong> capable of interpreting context, aligning patterns, and restoring readability to code distorted by the decompilation process.</p><h3>The LLM Advantage in Code Reconstruction</h3><p>Traditional refactoring tools operate on syntactic rules and pattern matching. They handle mechanical transformations well but struggle with semantic understanding. LLMs add contextual reasoning, inferring intent from usage patterns, recognizing domain-specific concepts, and maintaining consistency across thousands of files.</p><p>This capability was critical because the decompiled code was not just syntactically messy, but semantically unclear. Variable names such as ‘obj’, ‘flag’, and ‘num’ appeared thousands of times, and methods were named ‘method_0’, ‘method_1’, and so on. The code compiled, but it did not convey what the application actually did.</p><h3>Cleaning Compiler and Decompiler Artifacts</h3><p>Decompiled .NET code contains artifacts that do not reflect the original source. These patterns are byproducts introduced during compilation and decompilation and must be systematically cleaned:</p><h3>Redundant Type Casting</h3><p>The decompiler often generates defensive casts that were not present in the original code.</p><p>For example:</p><pre>string text = (string)((object)Session[&quot;UserName&quot;]);</pre><p>The double cast through object is unnecessary and reduces readability. LLMs identified these patterns across the codebase and simplified them:</p><pre>string text = Session[&quot;UserName&quot;] as string;</pre><h3>Unicode Escape Sequences</h3><p>The decompiler sometimes replaces ordinary characters with Unicode escape sequences, particularly in string literals:</p><pre>text = &quot;District Assessment System\u2014Property Management&quot;;</pre><p>The \u2014 represents an em dash, but as an escape sequence it reduces readability. LLMs converted these back to their actual characters while preserving intentional escapes for non-printable characters.</p><h3>Compiler-Generated Temporary Variables</h3><p>Compiler optimizations introduce temporary variables that obscure the actual logic:</p><pre>bool flag;<br>if (condition)<br>{<br> flag = true;<br>}<br>else<br>{<br> flag = false;<br>}<br>return flag;</pre><p>This can be simplified to:</p><pre>return condition;</pre><p>LLMs identified these patterns across thousands of methods and applied the appropriate simplifications without changing behavior. Developers still reviewed each transformation, but the LLM reduced manual effort significantly.</p><h3>Restoring Naming, Readability, and Intent</h3><p>Even with debug symbols stripped, LLMs inferred meaningful names for:</p><ul><li>Variables</li><li>Method parameters</li><li>Helper methods</li><li>Intermediate logic blocks</li></ul><p>These inferences were based on usage patterns, surrounding context, domain keywords, and the older snapshot of the code. The result was code that was not only correct, but understandable.</p><h3>Reintegrating Legacy Comments and Documentation</h3><p>Generic variable names are a major obstacle to code comprehension. When debug symbols are stripped during compilation, decompilers generate placeholder names, resulting in code that works but conveys little meaning.</p><h3>Inferring Variable Purpose from Context</h3><p>LLMs infer meaningful names by analyzing usage patterns. For example, consider this decompiled method:</p><pre>private void method_0(object obj, EventArgs args)<br>{<br>  int num = int.Parse(Request.QueryString[&quot;id&quot;]);<br>  DataTable dataTable = this.method_1(num);<br>  if (dataTable.Rows.Count &gt; 0)<br>    this.method_2(dataTable);<br>}</pre><p>From the surrounding context, an LLM can infer:</p><ul><li>num is parsed from a query string parameter called id, suggesting it represents a district or parcel identifier</li><li>method_1 retrieves data based on this ID, indicating a data access method</li><li>method_2 processes the results, likely binding them to a UI control</li></ul><p>This produces a more readable version:</p><pre>private void LoadDetails(object sender, EventArgs e)<br>{<br>  int detailId = int.Parse(Request.QueryString[&quot;id&quot;]);<br>  DataTable detailData = GetDetailtById(detailtId);<br>  if (detailData.Rows.Count &gt; 0)<br>    BindDetailGrid(detailData);<br>}</pre><p>The transformation reveals the programmer’s original intent, making the code immediately understandable to future maintainers.</p><h3>Leveraging Domain Knowledge</h3><p>LLMs also incorporated domain-specific knowledge from the older codebase snapshot. When the original code referenced specific concepts, those terms were reintroduced into the decompiled code where appropriate. This ensured consistency with the organization’s existing terminology.</p><h3>Reintegrating Legacy Comments and Documentation</h3><p>The customer still had a previous source code version, which contained valuable comments, explanations, and documentation. However, the code had evolved significantly, making it impossible to copy comments from the old version.</p><p>LLMs enabled a more structured approach:</p><ul><li>Align old commented code with its modern decompiled counterpart by matching structural signatures</li><li>Reinsert comments where the logic still matched</li><li>Rewrite or update comments where behavior had changed</li><li>Flag sections where the logic had diverged significantly, requiring manual review</li></ul><h3>Reconstructing Features Added After the Last Source Snapshot</h3><p>The most challenging part of the recovery was identifying and reconstructing features added between 2018 and the present. These features existed only in the production binaries and had to be reverse-engineered from decompiled IL code.</p><p>This required combining multiple sources of information:</p><ul><li>Decompiled logic and control flow</li><li>Runtime observations from the production environment</li><li>Application configuration files (web.config, appsettings)</li><li>Database schema analysis</li><li>Behavioral patterns from similar methods in the old codebase</li></ul><p>LLMs acted as synthesis engines, combining these signals into coherent explanations of what the code was doing. For example, if a new database table appeared in the schema, decompiled methods referenced it, and related configuration entries were present, the LLM could infer: “This feature implements batch invoice generation, storing invoice metadata in the InvoiceBatch table and generating PDFs asynchronously via a background worker process.”</p><p>This hypothesis was then validated through testing, allowing reconstruction of not just the code, but also the underlying business logic and architectural intent.</p><h3>Validating the Recovered Codebase</h3><p>Reconstruction required thorough validation. Every transformation, inferred name, and reconstructed feature had to be verified. A multi-layered validation approach was used:</p><h3>Static Analysis and Compilation</h3><p>The recovered code had to compile without errors or new warnings. Static analysis tools flagged potential issues such as null reference exceptions, unreachable code, and type mismatches, ensuring syntactic correctness.</p><h3>Behavioral Equivalence Testing</h3><p>The recovered application was deployed to a staging environment configured identically to production.</p><p>Critical workflows were executed side by side against both environments. Any discrepancies in output, database state, or error handling were investigated and resolved, confirming that the reconstructed logic matched production behavior.</p><h3>Database Integration Verification</h3><p>The data access layer was tested against a copy of the production database. Stored procedures, SQL queries, and ORM mappings were validated against the expected schema, including edge cases such as null values, constraint violations, and transaction rollbacks.</p><h3>Reconstructing Features Added After the Last Source Snapshot</h3><p>The 2010 snapshot did not reflect a decade of subsequent changes. Recovering these missing features required combining:</p><ul><li>Decompiled logic</li><li>Runtime observations</li><li>Application configuration</li><li>Database schema analysis</li><li>Old code similarities</li><li>LLM-assisted explanation and reconstruction</li></ul><p>This made it possible to identify and reproduce:</p><ul><li>New features</li><li>Updated business rules</li><li>Authorization changes</li><li>UI logic adjustments</li><li>Data transformations</li><li>Error-handling patterns</li></ul><p>The final code behaved identically to the production system.</p><h3>Validating the Recovered Codebase</h3><p>The recovered codebase was validated through a combination of:</p><ul><li>Compilation and static analysis</li><li>Manual code reviews focused on sensitive logic</li><li>Behavioral testing against the existing production environment</li><li>Database integration tests</li><li>Side-by-side diffing between decompiled and recovered logic</li><li>Replaying scenario inputs through both versions</li></ul><p>This ensured that the restored code faithfully matched the production behavior while remaining understandable for future developers.</p><h3>Outcome</h3><p>The customer regained full control over a previously inaccessible production system. The final deliverable included:</p><ul><li>A complete, buildable codebase</li><li>Clean and consistent C# code</li><li>A logical structure aligned with modern development practices</li><li>Recovered business rules and features</li><li>Restored documentation and comments</li><li>A maintainable foundation for future enhancements</li></ul><h3>Conclusion</h3><p>Decompilers recover the structure and logic of a codebase from compiled binaries. LLMs build on that foundation by restoring naming, readability, and intent. Used together, they enable a level of reconstruction that was previously impractical: a readable, coherent, maintainable codebase that closely reflects the original intent.</p><p>This approach provides a practical solution for organizations facing lost or incomplete .NET source code, turning a costly problem into a path for rebuilding and modernization.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=123142bca20c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/recovering-a-lost-asp-net-codebase-using-decompilers-and-llms-123142bca20c">Recovering a Lost ASP.NET Codebase Using Decompilers and LLMs</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Migrating from Fly.io to AWS: Key Challenges and Migration Considerations]]></title>
            <link>https://medium.com/trackit/migrating-from-fly-io-to-aws-key-challenges-and-migration-considerations-1890b4697f7e?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/1890b4697f7e</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cloud-services]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[flyio]]></category>
            <category><![CDATA[cloud-migration]]></category>
            <dc:creator><![CDATA[Dmitry Yakovlev]]></dc:creator>
            <pubDate>Fri, 27 Mar 2026 06:07:21 GMT</pubDate>
            <atom:updated>2026-03-27T06:07:20.535Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Iva0tL2XZEgz-xUMJR8qGA.png" /></figure><h3><strong>Overview</strong></h3><p>This guide outlines the key challenges and considerations when migrating an application from <a href="http://fly.io/">Fly.io</a>’s platform-as-a-service (PaaS) to AWS infrastructure using a lift-and-shift approach with minimal application changes. Beyond hosting, Fly.io also provides integrated observability via Prometheus metrics and supports CI/CD workflows through third-party integrations like GitHub Actions. It is intended as a practical guide for engineering teams evaluating or planning such a migration.</p><p>The analysis is based on the TaskVault sample application, a task tracker with file attachments built using Node.js, Express, PostgreSQL (via Prisma ORM), and S3-compatible storage. The application uses hexagonal architecture, which significantly simplifies the migration by isolating infrastructure concerns from business logic.</p><p>Each section below covers a specific area of the migration, identifies the challenges involved, and proposes solutions or workarounds.</p><p>While this guide focuses on Fly.io, the same migration patterns and considerations generally apply to similar developer-focused PaaS platforms such as <a href="https://render.com/">Render</a> and <a href="https://railway.com/">Railway</a>.</p><h3><strong>Why Migrate from Fly.io to AWS?</strong></h3><h4><strong>Beyond the early-stage platform</strong></h4><p>Fly.io is an excellent platform for moving fast: deploy in a few commands, managed Postgres, built-in object storage. It is the go-to choice for teams that want to ship without worrying about infrastructure.</p><p>But as applications scale and business requirements evolve, its limitations start to show. Less control over networking, a narrower service catalog, and compliance requirements (SOC2, HIPAA, ISO 27001) that enterprise customers increasingly demand from their vendors.</p><p>AWS is a massive ecosystem of over 200 services, and that breadth is precisely what makes it compelling at scale. Beyond the service catalog, AWS gives teams granular control over their networking layer through VPC, security groups, private subnets, VPC peering, and PrivateLink, which provides the kind of infrastructure control that PaaS platforms deliberately abstract away.</p><p>For enterprise deals, that abstraction becomes a blocker: many large organizations and third-party integrations explicitly require an AWS environment as a baseline. For engineering teams hitting these walls on Fly.io, migrating to AWS is less of a platform switch and more of a natural next step.</p><h4><strong>Scaling: where the gap becomes real</strong></h4><p>Machines on Fly.io are not provisioned on demand based on request traffic. They must be provisioned upfront, after which the platform starts or stops them as needed. Autoscaling exists, but it requires external Prometheus monitoring and triggering scale operations via CLI or API.</p><p>AWS, by contrast, handles this natively: <a href="https://aws.amazon.com/ecs/">Amazon ECS (Elastic Container Service)</a> on <a href="https://aws.amazon.com/fargate/">AWS Fargate</a> scales tasks automatically based on CPU, memory, or custom <a href="https://aws.amazon.com/cloudwatch/">CloudWatch</a> metrics. <a href="https://aws.amazon.com/lambda/">AWS Lambda</a> scales to thousands of concurrent executions transparently. For teams expecting unpredictable traffic spikes or rapid growth, this difference is significant.</p><h4><strong>Cost efficiency at scale</strong></h4><p>PaaS platforms come with a simplicity premium that compounds as traffic grows. At high volumes, moving to AWS and using <a href="https://aws.amazon.com/ec2/spot/">Spot Instances</a> or <a href="https://aws.amazon.com/ec2/graviton/">Graviton</a> processors can meaningfully reduce infrastructure costs. AWS also offers Savings Plans and Reserved Instances, where committing to a usage level unlocks substantial discounts. These options simply do not exist on Fly.io.</p><h4><strong>Database maturity</strong></h4><p>Fly.io’s managed Postgres is convenient but remains largely self-managed. Users are responsible for scaling and tuning. <a href="https://aws.amazon.com/rds/">Amazon RDS (Relational Database Service)</a> is a fully mature service with automated failover, point-in-time recovery, and multi-AZ replication out of the box. For production workloads where uptime is non-negotiable, this gap matters.</p><h3><strong>Architecture Transformation</strong></h3><p>The migration involves a fundamental shift from a container-based deployment model to an AWS container-based architecture using ECS Fargate. The table below maps Fly.io components to their AWS equivalents:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/632/1*ecHV8hVvwRsgeV2XFNvZvQ.png" /></figure><h4><strong>Challenge #1: Container Registry Migration</strong></h4><p>Fly.io builds and deploys Docker images directly from a Dockerfile using its built-in remote builders. On AWS, the Docker image must be pushed to <a href="https://aws.amazon.com/ecr/">Amazon Elastic Container Registry (ECR)</a> before ECS can pull and run it. The Dockerfile itself requires no modifications. The same image runs on both platforms.</p><h4><strong>Challenge #2: Service Discovery and Networking</strong></h4><p>Fly.io provides automatic service discovery via .flycast internal DNS and WireGuard-based private networking. On AWS, services communicate through VPC networking, security groups, and ALB target groups. The ECS service must be configured with proper health checks, target group registration, and security group rules to allow traffic from the ALB.</p><p><strong>Solution: </strong>Since this is a lift-and-shift migration, the Express application runs unchanged inside the same Docker container on ECS Fargate. No code modifications are required. The application listens on the same port (3000), uses the same middleware, and serves the same routes. Only the infrastructure configuration changes (from fly.toml to Terraform).</p><h3><strong>Database Migration</strong></h3><h4><strong>Challenge #1: Network Topology</strong></h4><p>Fly Postgres is accessed via Fly’s internal private network using .flycast DNS names (e.g., taskvault-db.flycast:5432). On AWS, RDS instances are accessed via public endpoints or through VPC private networking. The DATABASE_URL connection string must be updated to point to the RDS endpoint.</p><h4><strong>Challenge #2: Prisma Binary Targets</strong></h4><p>Prisma generates platform-specific query engine binaries. Fly.io’s Docker image uses Debian (debian-openssl-3.0.x), while the ECS container uses the same Debian base image (debian-openssl-3.0.x), so no binary target changes are needed if the same Dockerfile is used.</p><h4><strong>Challenge #3: Connection Pooling</strong></h4><p>Fly.io runs a persistent process that maintains a database connection pool. ECS Fargate also runs persistent containers, so connection pooling behavior is identical. Prisma’s default connection pool works out of the box without any configuration changes.</p><p><strong>Solution: </strong>No changes required. ECS Fargate runs long-lived containers just like fly.io, so Prisma’s connection pool operates identically. For high-traffic production workloads, Amazon RDS Proxy ($15–20/mo*) can be added as an additional optimization layer.</p><p><em>* Pricing may vary based on region, usage patterns, data transfer, and AWS pricing changes.</em></p><h3>Data Migration with AWS DMS</h3><p><a href="https://aws.amazon.com/dms/">AWS Database Migration Service (DMS)</a> is the recommended approach for migrating data from Fly Postgres to Amazon RDS. DMS provides a fully managed migration experience, supporting both full-load and change data capture (CDC) for minimal downtime migrations.</p><h4><strong>Step 1: Expose Fly Postgres Externally (Temporary)</strong></h4><p>Fly Postgres is only accessible via Fly’s internal private network (.flycast). To allow DMS to connect, temporarily expose the database externally using Fly.io’s native external connection feature: allocate a public IPv4 address (fly ips allocate-v4 — app taskvault-db), configure the fly.toml to expose port 5432 with the pg_tls handler, and redeploy. The database becomes accessible at taskvault-db.fly.dev:5432 with mandatory TLS encryption.</p><h4><strong>Step 2: Configure DMS</strong></h4><p>Create a DMS replication instance in the same VPC as the target RDS. Configure the source endpoint pointing to taskvault-db.fly.dev:5432 with SSL mode set to “none”, and the target endpoint pointing to the RDS instance in the private subnet. Create a full-load replication task to migrate all tables and data.</p><p>In the AWS console, the following appears under DMS → Dashboard → Replication Instance:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kn4T--TFPrzuoq8BoqRnDw.png" /></figure><p>And in DMS -&gt; Dashboard -&gt; Endpoints:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E5BXZOjDRm-6BiaGPJ7XQQ.png" /></figure><h4><strong>Step 3: Run Migration and Clean Up</strong></h4><p>Start the DMS replication task. DMS connects to Fly Postgres over the internet (TLS-encrypted), reads the data, and writes it to RDS in the private subnet. Once the task has started and completed, the following will appear in the AWS dashboard (DMS → Dashboard → Database migration tasks)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vdPq_9CaYi4nhxS0WhfD0g.png" /></figure><p>After verifying row counts match, immediately revoke external access to Fly Postgres by releasing the public IP (fly ips release — app taskvault-db) and delete the DMS replication instance to stop incurring costs.</p><p><strong>Security Considerations</strong></p><p>While the database is temporarily exposed, it remains protected by TLS encryption (enforced by the pg_tls handler) and PostgreSQL authentication (username and password). The exposure window should be minimized to the duration of the migration only. It is recommended to change the database password after revoking external access as an additional precaution.</p><h3><strong>Storage Migration</strong></h3><h4><strong>Challenge #1: Different Endpoints and Credentials</strong></h4><p>Tigris is S3-compatible but uses a different endpoint (fly.storage.tigris.dev) and its own access credentials. The AWS SDK configuration must be updated to use Amazon S3’s default endpoint and IAM role-based authentication instead of explicit access keys.</p><h4><strong>Challenge #2: Presigned URLs</strong></h4><p>Existing presigned download URLs generated by Tigris will stop working after migration. Any URLs stored in the database or shared externally will need to be regenerated from the new S3 bucket. Since TaskVault generates presigned URLs on-demand (not stored), this is handled automatically.</p><p><strong>Solution: </strong>The application already uses the AWS SDK v3 for S3 operations. On ECS Fargate, the SDK automatically uses IAM task role credentials (no explicit keys needed).</p><h3><strong>Data Migration with AWS DataSync</strong></h3><p><a href="https://aws.amazon.com/datasync/">AWS DataSync</a> Enhanced mode is the recommended approach for migrating object storage from Tigris to Amazon S3. Since May 2025, DataSync supports cross-cloud transfers without requiring an agent, making it ideal for S3-compatible sources like Tigris.</p><h4><strong>Step 1: Create Source Location (Tigris)</strong></h4><p>Configure a DataSync location of type “Other cloud object storage” with the Tigris endpoint (https://fly.storage.tigris.dev), the bucket name, and the Tigris access key and secret key credentials. Select Enhanced mode to enable agent-free cross-cloud transfer.</p><h4><strong>Step 2: Create Destination Location (Amazon S3)</strong></h4><p>Configure a DataSync location pointing to the Amazon S3 attachments bucket provisioned by Terraform. Assign an IAM role that grants DataSync read/write permissions on the bucket.</p><p>After this step, the following should be visible on the AWS dashboard (DataSync → Locations):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bBsjQdB_Pq0Ubxzz4N9FtQ.png" /></figure><h4><strong>Step 3: Create and Run the DataSync Task</strong></h4><p>Create a DataSync task linking the Tigris source to the S3 destination with the “Transfer all data” option. DataSync automatically parallelizes the transfer and verifies data integrity after completion. Once the task is created, it will appear on the dashboard (DataSync → Tasks) as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hdg6NoNldCPS6DPErpdfNQ.png" /></figure><p>Once the task has been executed, it will appear in DataSync → Task history as shown below:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zC7EnXoM-kph7p7WGCdKCw.png" /></figure><p>Once verified, delete the DataSync task and locations to avoid any recurring costs.</p><h4><strong>Cost</strong></h4><p>DataSync Enhanced mode charges $0.0125* per GB transferred. For a demo application with minimal data, the cost is effectively zero. For enterprise migrations with terabytes of data, DataSync provides significant advantages over manual tools: automatic parallelization, data integrity verification, and transfer monitoring through the AWS console.</p><p><em>* Pricing may vary based on region, usage patterns, data transfer, and AWS pricing changes.</em></p><h3><strong>Networking &amp; Security</strong></h3><h4><strong>Challenge #1: SSL/TLS Certificates</strong></h4><p>Fly.io automatically provisions and renews SSL certificates for all applications. On AWS, SSL is handled by <a href="https://aws.amazon.com/certificate-manager/">AWS Certificate Manager (ACM)</a> integrated with <a href="https://aws.amazon.com/cloudfront/">Amazon CloudFront</a>. Certificates must be provisioned in us-east-1 for CloudFront, regardless of the application region.</p><h4><strong>Challenge #2: Network Architecture Complexity</strong></h4><p>Fly.io provides automatic private networking between services via WireGuard. AWS offers more granular control through VPCs, subnets, security groups, and NAT gateways, but this adds significant configuration complexity compared to Fly.io’s zero-config approach.</p><h4><strong>Challenge #3: RDS Access Control</strong></h4><p>ECS Fargate tasks and RDS are placed in private subnets within the VPC. The Application Load Balancer sits in public subnets and forwards traffic to ECS targets in private subnets. ECS accesses S3 via a free S3 Gateway Endpoint. This architecture provides defense in depth without requiring a NAT Gateway for S3 access.</p><p><strong>Solution: </strong>Deploy ECS Fargate and RDS in private subnets with an ALB in public subnets. Use a free S3 Gateway Endpoint for storage access. All database connections are encrypted via PostgreSQL SSL within the VPC. For outbound internet access (e.g., external APIs), add a NAT Gateway (~$32/mo*).</p><p><em>* Pricing may vary based on region, usage patterns, data transfer, and AWS pricing changes.</em></p><h3><strong>Infrastructure as Code</strong></h3><h4><strong>Challenge: Configuration Complexity</strong></h4><p>Fly.io’s entire deployment configuration fits in a single fly.toml file (~20 lines). The equivalent AWS infrastructure requires Terraform configuration covering ECS, ECR, ALB, CloudFront, RDS, S3, IAM roles, and security groups.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*TnNUB5QBpyux_d9Dpu1M3g.png" /></figure><p><strong>Benefit: </strong>While Terraform requires more initial setup, it provides fine-grained control over every resource, supports team collaboration through remote state, and integrates with CI/CD pipelines. AWS CDK is an alternative for teams preferring imperative TypeScript over declarative HCL.</p><h3><strong>Conclusion</strong></h3><p>With a well-structured application, migrating from Fly.io to AWS is largely an infrastructure problem, not a code problem. The application logic, database schema, and business logic stay the same.</p><p>What changes is the layer underneath. And that layer, once on AWS, provides growing engineering teams with the control, the compliance, and the scalability they eventually need.</p><p>This approach introduces additional complexity. Terraform configurations, IAM roles, and VPC networking are not as simple as a Fly.io deploy. But this is a one-time investment that pays dividends as both the product and the team scale.</p><p>While this guide focuses on Fly.io, the same principles apply to similar developer-focused PaaS platforms such as <a href="https://render.com/">Render</a> and <a href="https://railway.com/">Railway</a>.</p><h3><strong>Migration Checklist</strong></h3><p>Follow these steps in order to complete the migration from Fly.io to AWS:</p><ol><li>Write Terraform configuration: define all AWS resources (VPC, ECR, ALB, ECS, RDS, S3, CloudFront, IAM)</li><li>Deploy AWS infrastructure: run terraform init and terraform apply to provision all resources</li><li>Build and push Docker image to ECR: build the existing Docker image and push it to Amazon Elastic Container Registry</li><li>Deploy ECS service: Terraform creates the ECS task definition and service, pulling the image from ECR</li><li>Run database migrations: dedicated ECS task executes npx prisma migrate deploy</li><li>Expose Fly Postgres externally: allocate public IP and configure pg_tls handler for temporary external access</li><li>Migrate database with AWS DMS: configure source endpoint (Fly Postgres), target endpoint (RDS), and run full-load replication task</li><li>Revoke Fly Postgres external access: release the public IP and change the database password</li><li>Migrate storage data with AWS DataSync: configure Tigris as source location (Enhanced mode, no agent), S3 as destination, and run the transfer task</li><li>Deploy frontend: sync static files to the S3 frontend bucket, invalidate CloudFront cache</li><li>Verify the migration: test health endpoint, CRUD operations, file uploads/downloads</li><li>Update DNS: point the domain to the CloudFront distribution</li><li>Decommission Fly.io: destroy Fly.io resources after confirming AWS deployment is stable</li></ol><h3><strong>Note: Why ECS Fargate over AWS App Runner?</strong></h3><p><a href="https://aws.amazon.com/apprunner/">AWS App Runner</a> is a simpler alternative for running containers on AWS, offering a PaaS experience similar to Fly.io. However, for a lift-and-shift scenario, <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html">Amazon ECS on AWS Fargate</a> is preferred for several reasons:</p><ul><li>Complete control over VPC, security groups, and network architecture</li><li>Support for one-off tasks (e.g., running database migrations independently)</li><li>Native integration with ALB for advanced routing and health checks</li><li>Better suited for production workloads requiring fine-grained infrastructure control</li></ul><p>App Runner remains a valid option for teams prioritizing simplicity over infrastructure control, but it would be closer to replacing one PaaS with another rather than a true lift &amp; shift into AWS.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1890b4697f7e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/migrating-from-fly-io-to-aws-key-challenges-and-migration-considerations-1890b4697f7e">Migrating from Fly.io to AWS: Key Challenges and Migration Considerations</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Giving AI the Keys: Controlling a Tesla with Amazon Bedrock AgentCore]]></title>
            <link>https://medium.com/trackit/giving-ai-the-keys-controlling-a-tesla-with-amazon-bedrock-agentcore-e06058766526?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/e06058766526</guid>
            <category><![CDATA[amazon-bedrock]]></category>
            <category><![CDATA[amazon-bedrock-agentcore]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Alexandre Sauner]]></dc:creator>
            <pubDate>Mon, 23 Mar 2026 12:24:06 GMT</pubDate>
            <atom:updated>2026-03-23T12:24:04.755Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3FgESlfQ_jYT9ngxc9UqNw.png" /></figure><p>Large language models are evolving from passive assistants into systems capable of taking action. With the rise of the Model Context Protocol (MCP) and agent frameworks, it is now possible to connect AI models to real-world systems in a structured and secure way.</p><p>As an internal experiment, one of our engineers built a demo that exposes Tesla vehicle controls to AI agents using AWS-native building blocks. The result is a secure, serverless architecture that allows an AI agent to check battery levels, start climate preconditioning, flash lights, or honk the horn through a controlled gateway.</p><p>This article provides a high-level overview of how the solution works, the architecture behind it, and how the workflow connects AWS services to a physical vehicle.</p><h3>The Core Idea</h3><p>At a high level, the system turns Tesla vehicle operations into MCP-compatible tools. Those tools are exposed to AI agents through <strong>Amazon Bedrock AgentCore Gateway</strong>, which acts as a managed bridge between language models and backend systems.</p><p>Instead of directly wiring a model to an API, the design introduces authentication, network isolation, observability, and controlled execution paths. Because AgentCore is built for production workloads, it provides structured tool invocation, identity enforcement, monitoring, and operational safeguards out of the box. The AI does not talk to the vehicle directly. It calls structured tools exposed through a gateway, and those tools are executed in a tightly controlled AWS environment.</p><h3>Solution Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oZSi5WvZ-0WYO0TMoMBJsQ.jpeg" /></figure><p>The solution is built around five core components:</p><h3>1. Bedrock AgentCore Gateway</h3><p>The gateway exposes the MCP server endpoint that AI agents connect to. It acts as the public-facing control layer and ensures that all tool invocations are authenticated and properly routed.</p><h3>2. AWS Lambda</h3><p>A Lambda function serves as the execution engine for MCP tool calls. When the AI requests an action, such as retrieving vehicle data or triggering a command, the request is processed here. This layer handles business logic, token management, and API communication.</p><h3>3. Amazon Cognito</h3><p>Authentication is handled through <strong>Amazon Cognito</strong>, which issues JWT tokens. Only authenticated users or AI clients can invoke the MCP endpoint. This prevents anonymous access and ensures that vehicle commands are tightly controlled.</p><h3>4. Amazon ECS on Fargate</h3><p>Tesla’s vehicle-command proxy runs in <strong>Amazon ECS</strong> using Fargate. This proxy handles secure vehicle communication and operates inside a private subnet. It does not have direct public internet exposure.</p><h3>5. VPC with Private Networking</h3><p>The system is deployed in a Virtual Private Cloud with public and private subnets. Outbound traffic flows through a NAT gateway, ensuring the vehicle-command proxy remains inaccessible from the public internet while still reaching Tesla’s APIs securely.</p><h3>Workflow Overview</h3><p>The workflow can be broken down into a clear sequence:</p><ol><li>A user authenticates via Cognito.</li></ol><p>2. An AI agent connects to the Bedrock AgentCore Gateway using MCP.</p><p>3. The agent invokes a specific tool, for example retrieving vehicle state.</p><p>4. The Gateway forwards the call to Lambda.</p><p>5. Lambda:</p><ul><li>Validates authentication</li><li>Retrieves required secrets from AWS Secrets Manager</li><li>Orchestrates the request and forwards vehicle commands to the vehicle-command proxy running on ECS</li><li>Refreshes Tesla OAuth tokens when required</li></ul><p>6. The vehicle-command proxy:</p><ul><li>Handles secure communication with the Tesla Fleet API</li><li>Signs and forwards vehicle commands</li><li>Returns the response to Lambda</li></ul><p>7. The response flows back through the same path to the AI agent.</p><p>This separation ensures:</p><ul><li>No direct exposure of Tesla credentials</li><li>No public exposure of the vehicle-command proxy</li><li>Controlled execution of vehicle actions</li><li>Automatic token refresh when Tesla OAuth tokens expire</li><li>Clear separation between Lambda orchestration and the vehicle-command proxy, which handles direct communication with the Tesla Fleet API</li></ul><h3>Security Model</h3><p>Security is a foundational aspect of the implementation.</p><ul><li>All sensitive credentials are stored in AWS Secrets Manager.</li><li>The vehicle-command proxy runs in a private subnet.</li><li>TLS encryption is used between Lambda and the proxy.</li><li>Access to the MCP endpoint requires Cognito-issued JWT tokens.</li><li>Tesla OAuth tokens are rotated automatically when needed.</li></ul><p>Rather than embedding credentials or allowing direct vehicle API access, the system introduces layered trust boundaries. Every interaction must pass authentication and controlled execution logic before reaching the vehicle.</p><h3>Why This Matters</h3><p>This demo illustrates how AI agents can move beyond content generation into controlled, real-world actions without compromising security or architectural discipline.</p><p>It also demonstrates how <strong>AWS Lambda</strong>, <strong>Amazon ECS</strong>, and <strong>Amazon Cognito</strong> can be combined with Bedrock AgentCore to expose operational systems safely to AI-driven workflows.</p><p>While controlling a vehicle is a compelling example, the same pattern applies to:</p><ul><li>Media processing pipelines</li><li>Infrastructure automation</li><li>Internal business systems</li><li>IoT devices</li><li>Content publishing workflows</li></ul><p>Any system that can be abstracted as structured tools can be exposed to AI agents using a similar architecture.</p><h3>Implementation Reference</h3><p>The complete implementation, deployment scripts, and infrastructure templates are available here:</p><p><strong>GitHub Repository: </strong><a href="https://github.com/trackit/agentcore-gateway-tesla">https://github.com/trackit/agentcore-gateway-tesla</a></p><h3>Conclusion</h3><p>This project demonstrates how AI agents can securely interact with physical systems using AWS-native components and the MCP standard. The architecture combines Bedrock AgentCore Gateway with serverless compute, containerized services, and identity management to create a controlled bridge between language models and real-world operations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e06058766526" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/giving-ai-the-keys-controlling-a-tesla-with-amazon-bedrock-agentcore-e06058766526">Giving AI the Keys: Controlling a Tesla with Amazon Bedrock AgentCore</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Evaluating Video AI for Search: TwelveLabs Pegasus vs. Marengo]]></title>
            <link>https://medium.com/trackit/evaluating-video-ai-for-search-twelvelabs-pegasus-vs-marengo-9b8beab8b046?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/9b8beab8b046</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[twelvelabs]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[video-production]]></category>
            <dc:creator><![CDATA[Leandro Mota]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 14:50:12 GMT</pubDate>
            <atom:updated>2026-03-20T14:50:11.015Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_p2vImFJDw1Ys4J65Lln8g.png" /></figure><p>Imagine building a video search engine for a streaming platform. Users may enter queries such as “show me all the penalty kicks” or “find scenes where characters argue.” But how should one go about choosing the right AI model to power that search? And how can its performance be measured in a reliable way?</p><p>This is the challenge TrackIt faced when evaluating <a href="https://www.twelvelabs.io/blog/a-tour-of-video-understanding-use-cases">Twelve Labs’ video understanding models</a> on <a href="https://aws.amazon.com/bedrock/">Amazon Bedrock</a>. The goal was to compare two fundamentally different approaches: <a href="https://www.twelvelabs.io/blog/introducing-pegasus-1-2">Pegasus</a>, which generates textual descriptions from videos, and <a href="https://www.twelvelabs.io/blog/marengo-3-0">Marengo</a>, which converts videos and queries into mathematical representations (embeddings) for similarity search.</p><h3>Two Approaches to Video Understanding</h3><h4>Approach 1: Text Generation (Pegasus)</h4><p>Pegasus works like a storyteller. Given a video, it generates a detailed textual description, for example: <em>“In this scene, Jim places Dwight’s stapler in Jell-O as part of an elaborate office prank.”</em> It is an excellent choice for summaries and narrative descriptions. The question, however, is whether this type of model can reliably identify the specific scenes returned for a search query.</p><h4>Approach 2: Embedding Search (Marengo)</h4><p>Marengo takes a different approach. It converts both videos and text queries into numerical vectors known as embeddings. Search then becomes a similarity problem: a query like <em>“penalty kick”</em> is converted into an embedding and compared with embeddings generated from video segments to find the closest matches. Two versions were evaluated: the stable <strong>2.7</strong> and the newer <strong>3.0</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*848ntHIHoWPG3-GS9IFewQ.png" /></figure><h3>Building the Evaluation Framework</h3><h4>The Pegasus Pipeline: Judge-Based Evaluation</h4><p>To evaluate Pegasus, a five-step pipeline was implemented:</p><ol><li><strong>Dataset Preparation</strong>: Evaluation videos are converted into a format compatible with Amazon Bedrock.</li><li><strong>Inference Generation</strong>: Pegasus processes each video and generates scene descriptions.</li><li><strong>Automatic Upload</strong>: Results are formatted and uploaded to S3 storage</li><li><strong>Judge Evaluation</strong>: Claude AI (another language model) acts as an impartial judge, scoring how well Pegasus identified the requested scenes</li><li><strong>Results Analysis</strong>: Scores are aggregated and performance metrics are calculated</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/250/1*9wBgU6SoTdeOXkmwj4hlxA.png" /></figure><p>The architecture follows a modular design. Each step runs as a separate Python script that reads from and writes to predefined locations, making the pipeline easier to debug, modify, and extend.</p><h3>The Marengo Pipeline: Three-Stage Retrieval</h3><p>Evaluating embedding models requires a different approach. Instead of generating descriptions directly, the system retrieves video segments based on similarity between embeddings:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LSS6L2fzAwNGxnoqV7Ggnw.png" /></figure><ol><li><strong>Video Embedding</strong> (Asynchronous): Embeddings are precomputed for all video clips. This step runs once and the results are stored for later retrieval.</li><li><strong>Query Processing</strong> (Synchronous): Text queries are converted into embeddings and compared with the stored video embeddings to identify the most similar clips.</li><li><strong>Quality Assessment</strong>: Pegasus generates descriptions for the retrieved clips, and Claude AI evaluates their relevance to the original query.</li></ol><p>This pipeline uses one model (Pegasus) to help evaluate another (Marengo), creating a comprehensive assessment system.</p><h3>The Results: Surprising Findings</h3><h4>The Percentile Problem</h4><p>Our initial results showed something puzzling: Marengo 3.0 scored 0% on sports queries while Marengo 2.7 scored perfectly. Was the newer model broken?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UwTrUd01ddjjR3qcDnvRMg.png" /></figure><p>Not quite. The result turned out to be a measurement artifact. Marengo 3.0 uses a different scale for similarity scores, like measuring temperature in Celsius versus Fahrenheit. When we switched to percentile-based evaluation (looking at relative rankings rather than absolute scores), both versions performed perfectly.</p><h4>Key Performance Metrics</h4><p>The models performed as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ex5k_8c9pyDjtJCHv9MQxg.png" /></figure><p><strong>Pegasus 1.2 (Text Generation)</strong></p><ul><li>Generates detailed, coherent descriptions</li><li>Only 25% accuracy in identifying specific requested scenes</li><li>20% failure rate on longer videos</li><li>Best for: General video summaries, not precision search</li></ul><p><strong>Marengo 2.7 (Embeddings)</strong></p><ul><li>Perfect retrieval accuracy (100%)</li><li>Higher confidence scores (0.34 average similarity)</li><li>Zero failures</li><li>Best for: Production video search systems</li></ul><p><strong>Marengo 3.0 (Embeddings)</strong></p><ul><li>Perfect ranking ability (when measured correctly)</li><li>Lower absolute scores (0.14 average)</li><li>Slightly faster (3% improvement)</li><li>Trade-off: Speed vs. confidence calibration</li></ul><h3>Technical Architecture: Building for Scale</h3><p>The evaluation framework incorporated several design patterns worth highlighting:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_3HCak-3spFYkODZ_z1Yvg.png" /></figure><h4>Configuration-Driven Design</h4><p>Each script starts with a CONFIG dictionary containing model IDs, S3 buckets, and file paths. This makes it easy to switch between models or datasets without modifying the code.</p><h4>Asynchronous Processing</h4><p>Video embedding is computationally expensive. The framework uses Amazon Bedrock’s async invocation pattern: submit jobs, poll for completion, then download results. This allows multiple videos to be processed in parallel.</p><h4>Unified Reporting</h4><p>A master script (generate-report.py) combines results from all models using Claude Opus 4.5 to create comprehensive reports. It reads multiple JSONL files, aggregates metrics, and produces both detailed analysis and CSV summaries.</p><h4>Cost Tracking</h4><p>Every script includes cost estimation based on video duration and token usage. This helps teams budget their AI expenses, crucial when processing hours of video content.</p><h3>Lessons Learned</h3><h4>1. Metrics Matter</h4><p>The mAP (mean Average Precision) score of 0 for Marengo 3.0 was misleading. After implementing percentile-based evaluation, it became clear that both models were equally effective at ranking results because they simply used different score scales.</p><h4>2. Different Models, Different Strengths</h4><p>Text generation models excel at creating human-readable content but struggle with precision tasks. Embedding models are fantastic for search but require careful threshold tuning.</p><h4>3. Production Considerations</h4><p>Higher similarity scores are not just numbers. They affect:</p><ul><li>API confidence thresholds</li><li>Vector database performance</li><li>User trust in results</li></ul><h4>4. Evaluation is Iterative</h4><p>Our framework evolved from simple metrics to dual evaluation approaches as we discovered edge cases and measurement artifacts.</p><h3>The Verdict</h3><p>For production video search systems, <strong>Marengo 2.7</strong> emerged as the winner. Although both Marengo versions having perfect ranking ability, 2.7’s better-calibrated confidence scores make it more suitable for real-world applications where results must be filtered.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PqLI8qK0zqls5Ci04WoKWw.png" /></figure><h3>Extensible Evaluation Framework</h3><p>By separating evaluation into modular components and using multiple metrics, the framework provides a foundation for continuous model assessment. The code architecture, with its configuration-driven design and clear separation of concerns, makes it easy to add new models or evaluation criteria.</p><h3>Technical Note</h3><p>For those interested in the implementation details, the framework consists of the following:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yfTDo3oiJq1E2_oKnIznSA.png" /></figure><ul><li><strong>Pegasus Pipeline</strong>: 5 Python scripts for end-to-end evaluation</li><li><strong>Marengo Pipeline</strong>: 3-stage evaluation with embedding comparison</li><li><strong>Unified Reporting</strong>: Automated report generation using Claude Opus 4</li><li><strong>Cost Tracking</strong>: Built-in estimation for all model invocations</li><li><strong>Dual Metrics</strong>: Both threshold-based and percentile-based evaluation</li></ul><p>The modular architecture allows teams to adapt the framework for their own model evaluation needs, whether for video, text, or other AI applications.</p><p>Readers can access the code <a href="https://github.com/trackit/twelvelabs-model-evaluation"><strong>here</strong></a><strong> </strong>and contribute to it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b8beab8b046" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/evaluating-video-ai-for-search-twelvelabs-pegasus-vs-marengo-9b8beab8b046">Evaluating Video AI for Search: TwelveLabs Pegasus vs. Marengo</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do We Really Need Design? Understanding Its Role in Modern Product Development]]></title>
            <link>https://medium.com/trackit/do-we-really-need-design-understanding-its-role-in-modern-product-development-041a75102275?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/041a75102275</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Paula Soares]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 06:04:55 GMT</pubDate>
            <atom:updated>2026-03-18T06:04:54.395Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Written by Isabela Teodoro and Paula Soares, UX/UI Designers at TrackIt</em></p><p>UX writing, product design, interaction design, UX/UI, business design, design research, industrial design, graphic design, metadesign, and prompt design. Anyone who has spent time in product or technology environments has probably heard at least one of these terms. But what exactly is the difference between them? Is it necessary to have a single professional for each of these roles?</p><p>Not necessarily! Design, as both a field of study and practice, stems from a holistic view of the world around us and from applying that view to the creation of services, products, and solutions made by people and for people.</p><p>However, how can the role of this professional be understood in an abstract work environment such as technology?</p><p>It may be difficult to see how a professional traditionally associated with tangible objects can work with more abstract elements, such as interaction flows in cloud storage systems, navigation architectures, or digital journeys.</p><p>And in the same vein, how can value be delivered through something that does not yet exist in the real world, such as research into future market trends?</p><p>There are many nuances, but one result is clear: projects that involve designers from the beginning through delivery tend to achieve better outcomes in usability, accessibility, and efficiency.</p><p>Research conducted by the <a href="https://www.dmi.org/page/DesignValue/Design-Value-Index.htm?utm_source=chatgpt.com">Design Management Institute</a> indicates that design-driven companies outperformed the S&amp;P 500 index, a benchmark created by the financial agency Standard &amp; Poor’s that tracks 500 of the largest publicly traded companies in the United States and is widely used as a global reference for market performance. According to the study, organizations with strong design maturity surpassed this index by more than 200% over a decade, demonstrating that integrating design into strategic processes can generate measurable impacts on innovation, competitiveness, and financial returns.</p><h3>When Functionality Is Not Enough</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mrhxNIyGnNI4RfoiGH2jFQ.png" /></figure><p>When a technology project is planned, the initial budget often prioritizes professionals responsible for the technical structure, such as developers, engineers, and data specialists. From a short-term feasibility perspective, this makes sense, since these professionals effectively build the solution.</p><p>However, when the solution is intended to be used by people, technical functionality alone does not guarantee success. One way to understand this is through the analogy of building a house: it is possible to invest in high-quality materials, a solid foundation, and complex structural systems, but if the entrance door is difficult to identify or open, the space may not be used.</p><p>Design acts precisely to prevent this type of situation. By considering perceptual, cultural, and behavioral aspects, it seeks to ensure that the “door” of a product, whether an interface, flow, or service, clearly communicates how it should be used. Concepts such as <em>affordances </em>(design cues that suggest how something should be used)<em> </em>help make interaction intuitive, reducing cognitive effort, errors, and frustration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KJiX8mvTehRvOgof7N9Xrw.png" /><figcaption><em>Good design anticipates friction and removes it.</em></figcaption></figure><p>The presence of design directly impacts economic indicators and project efficiency. This happens because design is not merely an aesthetic layer. It also operates as a tool for investigation, translation, and mediation between human needs, technological possibilities, and business goals.</p><p>Understanding design solely in terms of staffing costs diminishes its role; in practice, design influences structural project decisions, guides priorities, and helps avoid rework, connecting financial performance and quality of experience as parts of the same process. Design culture acts as a force multiplier for existing production resources, blending and refining the best outputs into cohesive ideas. These processes can ultimately imbue the final product with a clear signal of how it should be used, what designers call an affordance, rather than settling for a functional but unintuitive outcome.</p><h3>Design Begins with People</h3><p>Because design’s central goal is to facilitate people’s interaction with and understanding of objects or environments, it always begins with a consideration of the end user’s perspective. This means understanding usage patterns, habits, and the contexts in which people will interact with a design. From this understanding, it becomes possible to define requirements, functionalities, and communication approaches more appropriately.</p><p>In development environments, projects may not always begin with a human-centered investigation. Requirements may arrive predefined, driven by technical goals, adoption of emerging technologies, computational precision, or system optimization. In this process, the primary point of contact, the user’s interaction with the proposed solution, can become secondary.</p><p>Having a designer actively involved in a project broadens the perspective on accessibility, language, context, and visual references appropriate for the target audience, directly contributing to making the solution understandable, usable, and meaningful.</p><h3>The Expanding Role of Design</h3><p>Design is grounded in a holistic premise where both designers and non-designers can appropriate it not only as a profession but also as a tool for understanding scenarios, problems, and hypotheses. In this sense, it acts as a mediator between complexity and comprehension.</p><p>This perspective contrasts with the historical perception of design during the industrial era, when the designer’s role was largely restricted to the formal conception of artifacts produced at a large scale. Nowadays, design extends beyond that limit and also operates in the analysis of systems, services, experiences, and organizational strategies — what a plot twist, huh?!</p><p>This view of design’s role is explored by Brazilian design historian and theorist<em> Rafael Cardoso</em> in<em> Design for a Complex World</em>, where he describes design as “<strong><em>a</em></strong> <strong><em>field of broad possibilities within a world marked by interdependence and layered complexity.”</em></strong></p><p>His views reflect a broader shift in how design is understood today, moving beyond the mere creation of aesthetic objects toward a field that interprets realities and translates complex systems into understandable experiences.</p><h3>What Design Role or Segment Do I Need for My Project?</h3><p>Before defining how many or which design roles are needed on a team, it is essential to understand the context in which the project operates and the objectives it seeks to achieve. This is the first step toward determining whether multiple specialized design roles are actually required or whether a generalist can address initial demands.</p><p>In technology projects, for example, interdisciplinary teams capable of fostering productive exchanges between development and design are prevalent, especially when the goal is to build digital or physical artifacts involving interfaces and human-computer interaction. In these scenarios, it becomes easier to recognize the need for designers focused on user experiences, such as UX/UI designers, who are responsible for shaping how people understand, navigate, and use the final product.</p><p>A Product Designer, for instance, when assigned as the sole design role on a project, can contribute beyond usability and user-experience principles by bringing a systemic view of the business, metrics, technical feasibility, and product strategy.</p><p>Ultimately, distributing responsibilities and specializations should be determined by the project’s maturity level, operational complexity, and expected impact. Early-stage projects or companies like startups tend to benefit from more generalist professionals, while larger initiatives involving multiple products, audiences, or channels may require deeper specialization, with dedicated design squads or teams focused on specific areas of the product.</p><h3>The Now and What Comes Next</h3><p>As of early 2026, one of the most visible trends is the growing use of Artificial Intelligence as an everyday tool for work and productivity. Automated systems already assist with drafting emails, documenting meetings, summarizing long pieces of content, and even creating digital interfaces and interaction flows. These tools are significantly expanding the productive capacity of teams and reshaping how many processes are carried out.</p><p>As similar solutions multiply, differentiation, clarity, and meaning become increasingly important in how products and services are perceived. Artificial Intelligence can accelerate production, but without expert direction, output quality suffers and becomes predictable.</p><p>This is where design plays a critical role. By focusing on human needs, contexts of use, and the clarity of interactions, designers help ensure that technological capabilities translate into experiences that people can actually understand and use.</p><p>The differentiator will not simply be what can be built, but how clearly and meaningfully those solutions work for the people they are intended to serve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=041a75102275" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/do-we-really-need-design-understanding-its-role-in-modern-product-development-041a75102275">Do We Really Need Design? Understanding Its Role in Modern Product Development</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Cloudflare to CloudFront with AWS WAF: Wallbox CDN Migration]]></title>
            <link>https://medium.com/trackit/from-cloudflare-to-cloudfront-with-aws-waf-wallbox-cdn-migration-752f5e0ab99f?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/752f5e0ab99f</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[cloudflare]]></category>
            <category><![CDATA[aws-cloudfront]]></category>
            <dc:creator><![CDATA[Matthieu Hausermann]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 10:57:24 GMT</pubDate>
            <atom:updated>2026-03-17T10:57:22.915Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2fd8Jp_xuwHzvNEe0MTK3Q.png" /></figure><h3>Challenge</h3><p>Wallbox, a global provider of smart EV charging solutions, engaged TrackIt in partnership with AWS to migrate its CDN footprint from Cloudflare to Amazon CloudFront. The effort required deep expertise in CDN architecture, edge behavior, routing logic, security rules, and multi-region traffic patterns. Wallbox needed a team capable of auditing the existing configuration, designing a CloudFront architecture that met all functional requirements, and carrying out the migration with precision while maintaining service availability.</p><h3>Implementation</h3><p>TrackIt conducted a full technical discovery to analyze Cloudflare configurations, traffic profiles, API requirements, and security controls. New CloudFront distributions were deployed and tuned for caching, routing, and performance. AWS WAF (Web Application Firewall) was introduced to provide a unified security layer with standardized rules and improved protection for API and application endpoints.</p><p>TrackIt executed the migration through a phased domain cutover that validated performance, confirmed rule behavior, and ensured a controlled transition across regions. TrackIt coordinated closely with AWS to carry out the rollout in alignment with Wallbox’s technical requirements.</p><h3>Outcome</h3><p>Wallbox successfully transitioned from Cloudflare to Amazon CloudFront with stable performance and secure traffic handling across all regions. The new architecture provides a scalable, AWS-native delivery layer with standardized WAF protections and validated CloudFront distributions. The migration met the established technical success criteria and prepared Wallbox for future enhancements of its global delivery performance.</p><h3>Highlights</h3><ul><li>Traffic cutover was executed in phases with no unplanned downtime</li><li>Successful migration of all planned domains and configurations</li><li>Unified security layer implemented with AWS WAF</li></ul><blockquote><em>“TrackIt delivered the technical expertise we needed for our CloudFront migration. The collaboration was smooth, communication was clear, and the final deployment met all of our requirements. We are very satisfied with the overall experience.” — Pablo Murga, SRE Manager</em></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=752f5e0ab99f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/from-cloudflare-to-cloudfront-with-aws-waf-wallbox-cdn-migration-752f5e0ab99f">From Cloudflare to CloudFront with AWS WAF: Wallbox CDN Migration</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[TAMS on Kubernetes: Architecture and Implementation]]></title>
            <link>https://medium.com/trackit/tams-on-kubernetes-architecture-and-implementation-44ba46f10eef?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/44ba46f10eef</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[media]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Eynard Clarisse]]></dc:creator>
            <pubDate>Fri, 27 Feb 2026 16:37:44 GMT</pubDate>
            <atom:updated>2026-02-27T16:37:42.137Z</atom:updated>
            <content:encoded><![CDATA[<p>This guide builds on the foundational concepts introduced in <a href="https://medium.com/trackit/tams-on-kubernetes-architecting-cloud-agnostic-time-addressable-media-storage-13355f3371ab"><em>TAMS on Kubernetes</em></a>, which provides essential architectural context for the implementation discussed below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6CVhMaDOjWC7WutSl6g6aQ.png" /></figure><h3>Introduction</h3><p>Modern media systems generate continuous streams of time-based data. Recording, segmenting, indexing, and retrieving that data reliably is not only a storage problem. It is an architectural one.</p><p>The Time Addressable Media Storage (TAMS) specification provides a structured way to reference and manage media over time. What matters in practice is how that specification behaves inside a real deployment, under real operational constraints.</p><p>This article presents a Kubernetes-native implementation of the TAMS API, designed around a single core principle: <strong>modularity and cloud-agnosticism</strong>.</p><p>The workflow addresses a persistent challenge in modern cloud architectures: vendor lock-in. The system is designed so that storage backends and repository layers remain fully interchangeable. The resulting TAMS service can run on any provider, migrate between environments, or operate in hybrid setups without code changes, requiring only configuration adjustments.</p><h4>Article Overview</h4><p>This article examines the technical decisions, patterns, and architectural choices that make the TAMS implementation robust and extensible. It covers:</p><ul><li>How layered architecture separates business logic from infrastructure concerns</li><li>How the dependency injection system enables seamless component replacement</li><li>The complete lifecycle of a TAMS request, from HTTP endpoint to storage backend</li><li>How to implement custom repository adapters or backend connectors</li><li>Best practices for testing, monitoring, and deploying the service</li></ul><h3>Solution Architecture</h3><p>The TAMS implementation follows a layered architecture that strictly separates concerns and dependencies. This structure keeps the system testable, maintainable, and modular.</p><figure><img alt="Tams on kubernetes: architecture schema" src="https://cdn-images-1.medium.com/max/1024/1*HeCJoFd3VSPHHSkxVGQT-w.png" /></figure><p>The responsibilities of each layer are outlined below.</p><h4>HTTP Layer</h4><p>The HTTP layer manages all external interactions. Its responsibilities include:</p><ul><li>Parsing and validating incoming requests</li><li>Authentication and authorization, when configured</li><li>Routing requests to the appropriate service methods</li><li>Serializing responses and setting HTTP status codes</li><li>Handling errors and returning user-facing messages</li></ul><p>This layer remains unaware of storage implementations or business logic details. It validates input and delegates execution to the service layer.</p><h4>Service Layer</h4><p>The service layer contains the core business logic. It:</p><ul><li>Orchestrates operations across repository and backend layers</li><li>Implements TAMS-specific logic such as time calculations, flow management, and segment addressing</li><li>Enforces business rules and constraints</li><li>Coordinates transactions across multiple storage operations</li><li>Handles errors from lower layers and applies retry strategies where appropriate</li></ul><p>The service layer depends only on interfaces, never concrete implementations, making it completely independent of infrastructure choices.</p><h4>Repository Layer</h4><p>The repository abstraction manages metadata and flow state. This layer:</p><ul><li>Provides CRUD operations for TAMS flows and their metadata</li><li>Abstracts away the underlying database or key-value store</li><li>Handles query optimization and data consistency</li><li>Maps domain objects to storage representations</li></ul><p>Multiple repository implementations are supported through adapters, including DynamoDB for production use and an in-memory implementation for testing and development.</p><h4>Backend Layer</h4><p>The backend layer is responsible for media segment storage. It:</p><ul><li>Manages the physical storage and retrieval of media data</li><li>Handles large file operations efficiently</li><li>Provides streaming capabilities when needed</li><li>Manages storage lifecycle (retention, cleanup)</li></ul><p>The backend abstraction supports S3-compatible object storage and local filesystems, and can be extended to integrate additional storage systems.</p><h4>Architectural Benefits</h4><p>This layered, interface-driven design serves several practical objectives:</p><p><strong>Cloud Agnosticism</strong>: By depending exclusively on interfaces, infrastructure components can be replaced without altering business logic. DynamoDB can be swapped for PostgreSQL, Redis, or another data store. S3 can be replaced with MinIO, Azure Blob Storage, or Google Cloud Storage through configuration changes and a thin adapter layer.</p><p><strong>Testability</strong>: Each layer can be tested independently. The service layer operates with mock repositories and backends. Adapters are validated against their respective storage systems. Integration tests can rely on in-memory implementations to keep execution fast and deterministic.</p><p><strong>Incremental Migration</strong>: Deployments can begin with lightweight implementations such as in-memory repositories or local storage, then transition to production-grade systems like DynamoDB and S3 without rewriting the service layer.</p><p><strong>Performance Optimization</strong>: Clear separation of responsibilities allows each layer to be optimized in isolation. Caching can be introduced at the repository level. Connection pooling can be handled within adapters. Backend operations can be tuned independently of service logic.</p><p><strong>Team Scalability</strong>: Layered boundaries enable distributed ownership. Platform teams can focus on infrastructure adapters, while application teams concentrate on business logic and service behavior.</p><h3>Configuration Management</h3><p>Configuration follows the principle of explicit declaration. Every component required to run the service, from storage backends to repository implementations, is defined in a single, structured configuration file.</p><h4>Configuration Structure</h4><p>The configuration file is organized into four primary sections, each with clearly defined responsibilities:</p><pre># Database configuration - metadata storage<br>database:<br>  type: dynamodb<br>  region: us-east-1<br>  sourceTableName: tams-sources<br>  flowTableName: tams-flows<br>  segmentTableName: tams-segments<br>  endpoint: &quot;&quot;  # Optional: for DynamoDB Local<br><br># Backend configuration - media segment storage<br>backends:<br>  - id: main-storage<br>    type: s3<br>    default: true  # Exactly one backend must be default<br>    bucket: tams-segments<br>    region: us-east-1<br>    pathPrefix: flows/<br>  <br>  - id: backup-storage<br>    type: s3<br>    default: false<br>    bucket: tams-segments-backup<br>    region: us-west-2<br><br># Logging configuration<br>logs:<br>  level: info  # debug | info | warn | error<br>  format: json<br><br># Server configuration<br>server:<br>  port: 8080</pre><p>Configuration file location is resolved using one of the following sources: the — config-path CLI argument, the TAMS_CONFIG_PATH environment variable, or the default path ./config/default.yaml. Both YAML and JSON formats are supported.</p><h4>Type-Safe Configuration with Validation</h4><p>Configuration is validated at application startup using Joi schemas. Invalid configurations fail fast with clear, actionable error messages rather than surfacing later as runtime failures.</p><p>Validation is both type-aware and conditional. The selected database type determines which fields are required, and backend configurations include business rule validation beyond simple type checks.</p><p>The validation layer provides precise feedback for common errors. Missing required fields identify the exact field and section involved. Type mismatches report the expected and provided values. Invalid enum entries list the allowed options. Business rule violations explain the constraint that was not satisfied.</p><p>By enforcing these checks at startup, configuration issues are detected early, making deployment problems immediately visible and easier to diagnose.</p><h4>Validation and Loading</h4><p>Configuration loading is handled by the ConfigReader class, which coordinates parsing, normalization, validation, and caching to ensure consistent runtime behavior.</p><p>The process follows a defined sequence:</p><ol><li><strong>Path resolution: </strong>Determine the configuration file path from CLI arguments, environment variables, or the default location</li><li><strong>File parsing: </strong>Read and parse YAML or JSON content</li><li><strong>Multi-source merging: </strong>Overlay environment variables and CLI arguments</li><li><strong>Type normalization: </strong>Convert string inputs to their appropriate runtime types</li><li><strong>Schema validation: </strong>Execute Joi schemas with conditional rules</li><li><strong>Business rule enforcement: </strong>Validate cross-field constraints such as a single default backend and unique identifiers</li><li><strong>Caching: </strong>Store the validated configuration for subsequent access</li></ol><p>This structured loading flow ensures that configuration is resolved, validated, and normalized before any service components are instantiated, reducing the risk of runtime misconfiguration.</p><h4>Configuration in Kubernetes</h4><p>In production Kubernetes environments, configuration management is handled through a custom controller. Instead of manually coordinating separate ConfigMaps, Secrets, and Deployments, the entire TAMS service is deployed using a single <em>Store </em>custom resource within the tams.trackit.io API group.</p><p>The <em>Store </em>resource provides a unified interface for deployment. A single manifest defines database settings, backend storage, logging configuration, replica count, and secret references. What would traditionally require multiple Kubernetes resources is consolidated into a single declarative object.</p><pre>apiVersion: tams.trackit.io/v1alpha1<br>kind: Store<br>metadata:<br>  name: tams-production<br>  namespace: production<br>spec:<br>  database:<br>    type: dynamodb<br>    region: us-east-1<br>    flowTableName: tams-flows<br>    serviceTableName: tams-services<br>    mediaObjectTableName: tams-media-objects<br>  <br>  backends:<br>    - id: a8f3c2e1-4b7d-4c3a-9f1e-2d8b7c6a5e4f<br>      type: s3<br>      default: true<br>      bucketName: tams-segments-prod<br>      region: us-east-1<br>  <br>  logs:<br>    level: info<br>  <br>  server:<br>    port: 8080<br>  <br>  replicas: 3<br>  secretName: tams-aws-credentials<br>  serviceAccountName: tams-service-account</pre><p>When a <em>Store </em>resource is created or updated, the controller generates the required ConfigMaps, creates or updates Deployments with the appropriate volume mounts and environment variables, and injects credentials from referenced Secrets. The reconciliation loop continuously aligns the declared configuration with the running infrastructure.</p><p>This approach shifts TAMS deployment from coordinating multiple Kubernetes resources to managing a single declarative object. The result is reduced configuration drift and smoother alignment with GitOps workflows.</p><h4>Extending Configuration</h4><p>Adding new repository or backend types requires minimal changes, reflecting the system’s extensibility. The process is consistent across both layers and follows a structured three-step pattern aligned with the Open/Closed Principle.</p><p><strong>Step 1: Define TypeScript Types</strong>: Create an interface for the new configuration type and include it in the appropriate union. For a PostgreSQL repository, define connection parameters such as host, port, database, and credentials, then add it to the DatabaseConfig union. For an Azure Blob backend, define the connection string, container, and path prefix, and include it in the BackendConfig union.</p><p><strong>Step 2: Add Validation Schema: </strong>Create a Joi schema that mirrors the TypeScript interface and enforces the required validation rules. Specify mandatory fields, type constraints, value ranges such as valid port numbers, and format checks such as UUIDs or bucket naming conventions. Extend the conditional validation logic to include the new type alongside existing schemas.</p><p><strong>Step 3: Update Registration Logic</strong>: Extend the dependency injection registration to support the new type. Conditional infrastructure registration ensures that the appropriate adapter is instantiated based on configuration, without changes to business logic or other layers.</p><p>The configuration system supports new types without altering parsing or loading logic. Each adapter integrates by declaring its configuration requirements through TypeScript definitions and Joi schemas rather than modifying core configuration code.</p><h3>Dependency Injection System</h3><p>The dependency injection (DI) system connects application configuration to runtime behavior. Built on Tsyringe, it follows a clear flow: <strong>Configuration → Registration → Injection → Instantiation</strong>. Concrete implementations can be replaced, such as swapping DynamoDB for an in-memory store, through configuration alone without modifying business logic.</p><h4>Core Mechanics</h4><p>The system is built around three primary primitives:</p><p><strong>Tokens </strong>are<strong> </strong>type-safe identifiers that represent dependencies within the container.</p><pre>const sourceRepositoryToken = token&lt;SourceRepository&gt;(&quot;SourceRepository&quot;);</pre><p><strong>Providers</strong> define instantiation strategies:</p><ul><li>useValue: Registers a pre-created instance, such as configuration objects</li><li>useClass: Registers a class that the container instantiates automatically</li><li>useFactory: Registers custom construction logic that can depend on other injected components</li></ul><p>A<strong> Container</strong> stores and resolves dependencies, creating instances on-demand or returning cached singletons.</p><h4>Configuration to Runtime Flow</h4><p>At application startup, the validated configuration determines how infrastructure components are registered within the dependency injection container:</p><pre>const config = ConfigReader.getCachedConfig();<br><br>// Register configuration values<br>register(dynamodbConfigToken, { useValue: config.database });<br><br>// Conditionally register implementations<br>if (config.database.type === &quot;dynamodb&quot;) {<br> register(sourceRepositoryToken, { useClass: DDBSourcesRepository });<br>} else {<br> register(sourceRepositoryToken, { useValue: new MemorySourceRepository() });<br>}</pre><p>Components declare dependencies through property injection:</p><pre>export class DDBSourcesRepository implements SourceRepository {<br>  private readonly client = inject(dynamodbClientToken);<br>  private readonly tableName = inject(SourceTableNameToken);<br><br>  async getSource(id: string): Promise&lt;Source | null&gt; {<br>    const result = await this.client.send(<br>      new GetItemCommand({<br>        TableName: this.tableName,<br>        Key: { id: { S: id } },<br>      })<br>    );<br>    // ...<br>  }<br>}</pre><p>The container automatically resolves dependency chains. When DDBSourcesRepository is requested, it injects the DynamoDB client (created from config) and table name (extracted from config).</p><h4>Benefits</h4><p><strong>Modularity</strong>: Implementations can be swapped at registration time without altering business logic.</p><p><strong>Testability</strong>: Components can be replaced with mocks by registering alternative implementations, for example:</p><pre>register(sourceRepositoryToken, { useValue: mockRepository });</pre><p><strong>Type Safety</strong>: TypeScript enforces dependency contracts when compiling, reducing the risk of mismatches.</p><p><strong>Clear Boundaries</strong>: Dependencies flow in a single direction. The service layer depends only on repository interfaces, never on concrete implementations.</p><h4>Extension Pattern</h4><p>Adding a new repository type requires minimal changes:</p><pre>// 1. Implement interface<br>export class PostgresSourceRepository implements SourceRepository {<br> private readonly pool = inject(postgresPoolToken);<br> // … implementation<br>}<br><br>// 2. Register conditionally<br>export const registerPostgresInfra = () =&gt; {<br> register(sourceRepositoryToken, { useClass: PostgresSourceRepository });<br>};<br><br>// 3. Use unchanged<br>const repo = inject(sourceRepositoryToken); // Gets Postgres implementation</pre><p>The dependency injection system removes manual wiring while preserving clear component boundaries. New storage implementations integrate without modifying business logic, allowing the architecture to evolve without destabilizing existing layers.</p><h3>Extending the TAMS implementation</h3><p>The modular architecture allows custom storage solutions to be introduced without modifying the service layer. Two extension paths are available:</p><p><strong>Repository Adapters</strong>: Provide alternative metadata storage backends. The repository interface abstracts database operations, enabling integration with PostgreSQL, MongoDB, Redis, or any data store that supports CRUD operations and query capabilities.</p><p><strong>Backend Connectors</strong>: Integrate additional object storage systems for media segment storage. Any system capable of storing and retrieving binary data can be connected through the backend interface, including Azure Blob Storage, Google Cloud Storage, Cloudflare R2, or custom distributed storage solutions.</p><p>The implementation is fully open source and available for extension and contribution:</p><p><strong>Repository</strong>:<a href="https://github.com/"> </a><a href="https://github.com/trackit/tams-k8s">github.com/trackit/tams-k8s</a></p><p>Before working with the codebase, review the CONTRIBUTING.md file in the repository. It outlines coding standards, testing requirements, pull request workflow, and commit conventions. The focus here remains on architecture: what needs to be built and how each component integrates into the system.</p><h4>The Four-Step Implementation Process</h4><p>Adding a custom adapter follows a consistent process, whether implementing a repository or a backend connector:</p><ol><li><strong>Implement the Interface</strong>: Create an adapter class that satisfies the required contract</li><li><strong>Extend Configuration</strong>: Define the configuration schema for the new implementation</li><li><strong>Register in the DI System</strong>: Integrate the adapter into the dependency injection container</li><li><strong>Write Comprehensive Tests</strong>: Validate behavior and compatibility across layers</li></ol><p>The following sections walk through each step using parallel examples: a PostgreSQL repository adapter and an Azure Blob Storage backend connector.</p><h4>Step 1: Implement the Interface</h4><p>Each adapter must satisfy the relevant interface contract. The service layer depends exclusively on these interfaces, never on concrete implementations.</p><p><strong>Example</strong>: PostgreSQL Repository Adapter</p><pre>import { inject } from &#39;../../di&#39;;<br>import { postgresPoolToken } from &#39;./client&#39;;<br>export class PostgresSourceRepository implements SourceRepository {<br> private readonly pool = inject(postgresPoolToken);<br> async listSources(id: string): Promise&lt;Source | null&gt; {<br> // implementation for PostgreSQL<br> }<br> async getSourceById(source: Source): Promise&lt;void&gt; {<br> // implementation for PostgreSQL<br> }<br> async putSource(source: Source): Promise&lt;void&gt; {<br> // implementation for PostgreSQL<br> }<br>}</pre><p><strong>Key Implementation Principles:</strong></p><ul><li><strong>Interface Compliance</strong>: Implement every method defined in the interface contract</li><li><strong>Error Handling</strong>: Use error types consistent with those expected by the service layer</li><li><strong>Type Safety</strong>: Leverage TypeScript’s type system to enforce correctness when compiling</li></ul><h4>Step 2: Extend Configuration</h4><p>Each adapter requires configuration to connect to its underlying storage system. Extend the configuration schema to include the new type and its required parameters.</p><p><strong>Example</strong>: Azure Blob Storage Configuration</p><pre>// src/backend/types.ts<br>export interface AzureBackendConfig {<br> type: &quot;azure-blob&quot;;<br> connectionString: string;<br> container: string;<br> pathPrefix?: string;<br>}<br>// Update backend configuration union<br>export type BackendConfig = <br> | S3BackendConfig <br> | LocalBackendConfig <br> | AzureBackendConfig;<br>// Validation schema<br>export const AzureBackendConfigSchema = z.object({<br> type: z.literal(&quot;azure-blob&quot;),<br> connectionString: z.string().min(1),<br> Container: z.string().uuid(),<br>pathPrefix: z.string().optional(),<br>});</pre><p>Configuration File Example:</p><pre># config.yaml<br>database:<br> type: postgres<br> host: localhost<br> port: 5432<br> database: tams<br> user: tams_user<br> password: ${POSTGRES_PASSWORD} # From environment variable<br> maxConnections: 20<br> ssl: true<br>backends:<br> - id: &lt;UUID&gt;<br> type: azure-blob<br> connectionString: ${AZURE_STORAGE_CONNECTION_STRING}<br> container: tams-segments<br> pathPrefix: flows/<br> default: true<br> <br> - id: &lt;UUID&gt;<br> type: s3<br> bucketName: tams-backup<br> region: us-west-2<br>logs:<br> level: info<br>server:<br> port: 3000</pre><p><strong>Configuration Best Practices:</strong></p><ul><li><strong>Environment Variables</strong>: Store sensitive values such as passwords and connection strings outside the configuration file</li><li><strong>Sensible Defaults</strong>: Define defaults for optional fields where appropriate</li><li><strong>Validation</strong>: Validate configuration at startup and fail fast if constraints are not met</li><li><strong>Documentation</strong>: Clearly document each configuration field and its purpose</li></ul><h4>Step 3: Register in DI System</h4><p>Register the adapter within the dependency injection container so it can be instantiated and resolved by the service layer at runtime.</p><pre>// src/di/registration/infra.ts<br>export const registerInfra = async (config: Config) =&gt; {<br> // Always register configuration first<br> registerConfig(config);<br> // Conditionally register repository implementations<br> switch (config.database.type) {<br> case &quot;dynamodb&quot;:<br> await ensureDynamoTables();<br> registerDynamoInfra();<br> break;<br> <br> case &quot;postgres&quot;:<br> await ensurePostgresTables();<br> registerPostgresInfra();<br> break;<br> <br> case &quot;memory&quot;:<br> registerMemoryInfra();<br> break;<br> <br> default:<br> throw new Error(`Unknown database type: ${config.database.type}`);<br> }<br> <br> // Backend registration happens automatically via BackendManager<br> // which is registered in registerConfig()<br>};</pre><p><strong>Registration Principles:</strong></p><ul><li><strong>Conditional Registration</strong>: Register only the implementation specified in configuration</li><li><strong>Fail Fast</strong>: Throw clear errors for unknown types or invalid configuration</li><li><strong>Singleton by Default</strong>: Use useClass for stateless adapters and useValue for stateful instances</li></ul><h4>Step 4: Write Comprehensive Tests</h4><p>Testing ensures the adapter behaves correctly and remains compatible with the service layer. Validation should occur across three levels: unit tests, integration tests, and end-to-end tests.</p><p><strong>Level 1: Unit Tests</strong></p><p>Validate adapter logic in isolation using mocks for external dependencies.</p><p><strong>Level 2: Integration Tests</strong></p><p>Test the adapter against real external systems such as databases or storage services. These tests verify correct interaction with actual infrastructure.</p><p><strong>Testing Best Practices:</strong></p><ul><li><strong>Isolation</strong>: Each test should be independent and not rely on shared state</li><li><strong>Cleanup</strong>: Remove any created resources such as database records or storage objects after execution</li><li><strong>Determinism</strong>: Ensure tests produce consistent results across runs</li></ul><p>The architectural patterns and interfaces described here provide the foundation for building production-ready extensions. Adapters developed in alignment with these patterns can be submitted as pull requests for inclusion in the main repository.</p><h3>Conclusion</h3><p>This TAMS implementation demonstrates how modular, cloud-agnostic architecture can be achieved through disciplined interface design and dependency management. Clear separation of concerns and strict reliance on abstractions allow the system to adapt to different infrastructure environments while maintaining consistent behavior.</p><h4>Key Takeaways</h4><p><strong>Modularity Through Interfaces</strong>: Each component depends on interfaces rather than concrete implementations. New storage backends, repositories, or transport layers can be introduced without modifying existing business logic.</p><p><strong>Cloud Agnosticism</strong>: The same codebase runs across AWS, Google Cloud, Azure, on-premises infrastructure, or local environments. Infrastructure changes require configuration updates rather than code rewrites, reducing long-term dependency on any single provider.</p><p><strong>Operational Readiness</strong>: Built-in observability, health checks, and structured error handling support production deployment. Logging and metrics provide the visibility required for reliable operation.</p><p><strong>Developer Experience</strong>: Clear extension patterns, structured testing approaches, and well-defined boundaries make customization straightforward. Adding new adapters or optimizing components does not disrupt the overall architecture.</p><h4>Looking Forward</h4><p>This implementation establishes a strong foundation, while leaving room for continued evolution. TAMS services can expand in several directions:</p><ul><li><strong>Advanced Features</strong>: Segment versioning, time-based retention policies, or cross-region replication</li><li><strong>Performance</strong>: Distributed caching, CDN integration, or specialized indices for faster time-based queries</li><li><strong>Operations</strong>: Advanced monitoring, automated backup and restore, or disaster recovery capabilities</li><li><strong>Integration</strong>: Webhooks for flow events, stream processing pipelines, or GraphQL APIs</li></ul><p>The modular structure allows these enhancements to be introduced without disrupting existing functionality.</p><h4>Closing Thoughts</h4><p>Designing cloud-agnostic, modular systems requires discipline. Avoiding shortcuts that bind the architecture to specific implementations preserves long-term flexibility. The reward is an architecture that adapts to changing infrastructure, supports migration across environments, and remains maintainable as complexity grows.</p><p>The patterns outlined throughout this article provide a practical model for building adaptable services grounded in clear boundaries and interface-driven design.</p><p>For the complete implementation, additional examples, and updates, refer to the <a href="https://github.com/trackit/tams-k8s">GitHub repository</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44ba46f10eef" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/tams-on-kubernetes-architecture-and-implementation-44ba46f10eef">TAMS on Kubernetes: Architecture and Implementation</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Connecting AWS MediaTailor to Google Ad Manager for VOD SSAI]]></title>
            <link>https://medium.com/trackit/connecting-aws-mediatailor-to-google-ad-manager-for-vod-ssai-664951248cab?source=rss----d39762e03b65---4</link>
            <guid isPermaLink="false">https://medium.com/p/664951248cab</guid>
            <category><![CDATA[advertising]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[monetization]]></category>
            <category><![CDATA[cloud]]></category>
            <dc:creator><![CDATA[Alexian]]></dc:creator>
            <pubDate>Tue, 24 Feb 2026 06:20:40 GMT</pubDate>
            <atom:updated>2026-02-24T06:20:39.570Z</atom:updated>
            <content:encoded><![CDATA[<h3>Connecting AWS Elemental MediaTailor to Google Ad Manager for VOD SSAI</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*eU21Ucizqa6YY07ppiT6iA.png" /></figure><p>Monetizing on-demand video at scale requires control over ad decisioning, clean content conditioning, and deterministic stitching. When server-side ad insertion (SSAI) is introduced into a VOD workflow, the integration surface expands: manifests must be properly marked, ad requests must be formatted for server-side execution, and player expectations must be aligned with what the backend can realistically support.</p><p>Pairing <a href="https://aws.amazon.com/mediatailor/"><strong>AWS Elemental MediaTailor</strong></a> with <a href="https://admanager.google.com/home/"><strong>Google Ad Manager (GAM)</strong></a> enables server-side stitched ads while preserving the flexibility and reporting capabilities of GAM. However, the integration goes beyond pointing MediaTailor to a VAST endpoint. A production-ready setup requires:</p><ul><li>VOD HLS content with precise ad markers</li><li>GAM configured specifically for SSAI requests</li><li>MediaTailor connected to GAM’s server-side endpoint with the correct parameters</li><li>A clear strategy for features MediaTailor does not support natively, especially overlay (nonlinear) ads</li></ul><p>This article outlines the complete integration, including:</p><ul><li>Configuring GAM as an Ad Decision Server (ADS) for MediaTailor</li><li>Inserting VOD ad markers using MediaConvert with ESAM (Event Signaling and Management)</li><li>Key MediaTailor limitations for VOD, particularly overlays</li><li>Splitting responsibilities: MediaTailor for linear SSAI and a client-side stack for overlays</li></ul><h3>High-Level Architecture</h3><p>At a high level, the integration is structured as follows:</p><p><strong>Ingest &amp; Transcode</strong></p><ul><li>VOD mezzanine files are uploaded to Amazon S3.</li><li>An AWS Lambda function extracts the asset duration, generates the required ESAM (Event Signaling and Management) XML, and triggers an AWS Elemental MediaConvert job.</li><li>AWS Lambda coordinates the workflow, while AWS Elemental MediaConvert produces HLS outputs with embedded ad markers.</li><li>The final HLS assets are written to a dedicated S3 media output bucket.</li></ul><h4><strong>Ad Markers &amp; Personalization</strong></h4><ul><li>During transcoding, MediaConvert inserts HLS tags such as #EXT-X-CUE-OUT and #EXT-X-CUE-IN based on the ESAM response.</li><li>AWS Elemental MediaTailor reads the HLS manifest, detects ad markers, and calls Google Ad Manager configured as the Ad Decision Server.</li><li>GAM returns a VAST response. MediaTailor stitches linear creatives into the stream and generates a personalized manifest for each viewer.</li></ul><p><strong>Delivery</strong></p><ul><li>Amazon CloudFront uses the S3 output bucket as its origin.</li><li>Cloudflare sits in front of CloudFront using a CNAME configuration and defined cache rules for media delivery.</li><li>This setup separates origin storage from global distribution and edge-level optimizations.</li></ul><p><strong>Client</strong></p><ul><li>An HLS-compatible player such as Video.js with VHS plays the MediaTailor manifest.</li><li>Linear ads are stitched server-side using SSAI.</li><li>Overlay ads are rendered client-side using the Google IMA SDK and a separate GAM ad tag.</li><li>Optional client-side logic can enforce non-skippable linear ad breaks by reading MediaTailor metadata tracks.</li></ul><p>Conceptually, ownership is divided as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/644/1*hKXD455CnRxdpH889TSTSw@2x.png" /></figure><h3>Preparing Google Ad Manager for MediaTailor</h3><h4>Understand GAM Propagation Delay</h4><p>Every configuration change in GAM takes time to propagate across Google’s serving infrastructure.</p><p>This includes:</p><ul><li>Creating or editing line items</li><li>Updating targeting rules</li><li>Adding or removing creatives</li><li>Pausing or resuming orders</li></ul><p>Propagation typically takes up to 30 minutes. QA and debugging should account for this delay.</p><p>If a line item is modified and the SSAI endpoint is called immediately afterward, previously cached decisioning behavior may still be returned. Troubleshooting without accounting for propagation delay often leads to incorrect conclusions.</p><h4>Create a Video Ad Unit for SSAI</h4><p>MediaTailor expects a VAST response tied to a specific video ad unit. The structure must be explicit and consistent.</p><ol><li><strong>Create the ad unit:<br></strong>– In GAM, navigate to <strong>Inventory → Ad units</strong>.<br>– Create a <strong>Video or audio (VAST)</strong> ad unit under the right hierarchy.<br>– Define the allowed creative sizes (for the SSAI example: <strong>640x480</strong>).</li><li><strong>Generate the tag URL:<br></strong>– In the ad unit page, open the <strong>Tags</strong> tab.<br>– Select <strong>Google Publisher Tag for video and audio</strong> and click <strong>Continue</strong> through the wizard.<br>– At the end, GAM generates a base tag URL. This URL contains key parameters, including:<br>— iu= — the ad unit path (e.g. /12345678900/Ad-Unit-Name)<br>— sz= — the creative size (e.g. 640x480)</li></ol><p>This base URL will be adapted in two places:</p><ul><li>Once for <strong>MediaTailor SSAI</strong></li><li>Once for the <strong>client-side overlay implementation</strong> using the<strong> Google IMA (Interactive Media Ads) SDK</strong></li></ul><h4>Orders, Line Items, and Size Targeting</h4><p>Understanding GAM’s delivery model is critical for predictable SSAI behavior.</p><ul><li><strong>Orders</strong>: Typically created per advertiser or campaign.</li><li><strong>Line items</strong>: Define priority type, pacing, targeting rules, and associated creatives.</li><li><strong>AdSense / AdX</strong>: Managed by Google’s system-level demand. No manual order creation per buyer is required.</li></ul><p>For this integration, two targeting rules matter most:</p><p>GAM only evaluates line items that meet both conditions:</p><ul><li>The requested ad unit (iu=) is targeted, either directly or through a parent in the hierarchy.</li><li>The requested size (sz=) matches one of the creative sizes defined on the line item.</li></ul><p>To keep SSAI and client-side behavior predictable, use the same key creative sizes, for example 640x480, across:</p><ul><li>The ad unit configuration</li><li>All line items’ defined creative sizes</li><li>The SSAI ad tag URL</li><li>The client-side overlay ad tag URL</li></ul><p>Size mismatches are a frequent cause of empty VAST responses and inconsistent delivery between stitched and client-rendered ads.</p><h4>Configuring AWS MediaTailor to Use GAM as ADS</h4><h4>1. Enable SSL for GAM in AWS</h4><p>MediaTailor must make HTTPS requests to GAM’s server-side endpoint. In some AWS accounts, outbound access to this endpoint must be explicitly enabled.</p><p><a href="https://docs.aws.amazon.com/mediatailor/latest/ug/gam-integration-ssl.html">An AWS Support ticket</a> may be required to allow requests to:</p><p><a href="https://serverside.doubleclick.net/">https://serverside.doubleclick.net</a></p><p>Without SSL access properly enabled, MediaTailor will fail to retrieve VAST responses from GAM.</p><h4>2. Use GAM’s Server-Side Endpoint</h4><p>For SSAI workflows, the GAM server-side host must be used.</p><ul><li>Replace <em>pubads.g.doubleclick.net</em> with <em>serverside.doubleclick.net</em></li></ul><p>An example Ad Decision Server URL for MediaTailor:</p><pre>https://serverside.doubleclick.net/gampad/ads?iu=/12345678900/Ad-Unit-Name&amp;description_url=[session.referer]&amp;tfcd=0&amp;npa=0&amp;sz=640x480&amp;gdfp_req=1&amp;unviewed_position_start=1&amp;correlator=[session.id]&amp;vpos=preroll&amp;output=vast&amp;env=vp&amp;vpmute=0&amp;vpa=click&amp;ssss=mediatailor&amp;vad_type=linear</pre><p>Key parameters:</p><ul><li>iu=: GAM ad unit path</li><li>sz=: Creative size. Must match the ad unit and line item configuration.</li><li>output=vast&amp;env=vp: Requests VAST in video player mode.</li><li>gdfp_req=1&amp;unviewed_position_start=1: Standard video request flags.</li><li>vpos=: Preroll, midroll, or postroll depending on break context. MediaTailor may set or override this value.</li><li>ssss=mediatailor: Required. Indicates that the request originates from MediaTailor SSAI.</li><li>vad_type=linear: Restricts the response to linear creatives only.</li></ul><h4>3. Use MediaTailor Session Variables</h4><p>MediaTailor supports dynamic variable substitution at request time. These placeholders are resolved per playback session. Common examples include:</p><ul><li>[session.id] — per-session correlator.</li><li>[session.referer] — original page URL.</li></ul><p>These come from the MediaTailor session context (see <a href="https://docs.aws.amazon.com/mediatailor/latest/ug/variables-session.html">https://docs.aws.amazon.com/mediatailor/latest/ug/variables-session.html</a>).</p><p>In the sample URL:</p><ul><li>description_url=[session.referer]</li><li>correlator=[session.id]</li></ul><p>GAM receives stable, per-viewer identifiers that support frequency capping, reporting consistency, and demand optimization.</p><h4>4. Configure the MediaTailor VOD Configuration</h4><p>In the AWS console:</p><ul><li>Create or edit a <strong>VOD configuration</strong>:<br>– <strong>Source content</strong>: the CloudFront or S3 origin serving the <strong>pre-MediaTailor</strong> HLS VOD.<br>– <strong>Ad decision server URL</strong>: the GAM SSAI URL above.<br>– <strong>Ad marker type</strong>: SCTE-35 or HLS tags, depending on how MediaConvert was configured (covered later in this guide)</li></ul><p>When a player initiates a MediaTailor session, the following sequence occurs:</p><ol><li>MediaTailor fetches the origin manifest</li><li>Ad markers such as #EXT-X-CUE-OUT and #EXT-X-CUE-IN are identified</li><li>GAM is called for each ad break using the configured ADS URL</li><li>A personalized HLS manifest is generated, referencing stitched ad segments</li></ol><h4>Marking VOD Content with Ad Opportunities</h4><p>AWS Elemental MediaTailor does not infer where ads should be inserted. It relies entirely on explicit ad markers in the HLS manifest. For VOD workflows, a reliable method to insert those markers is AWS Elemental MediaConvert with ESAM (Event Signaling and Management).</p><p>This section provides a practical overview tailored to the MediaTailor and Google Ad Manager integration.</p><h4>ESAM Overview: SPN and MCCN</h4><p>MediaConvert consumes two ESAM XML documents:</p><ol><li><strong>SignalProcessingNotification (SPN)</strong>: Defines when ad events occur and their SCTE-35 semantics.</li><li><strong>ManifestConfirmConditionNotification (MCCN)</strong>: Defines which HLS tags are written at those events.</li></ol><p>These two documents are linked through:</p><ul><li>acquisitionPointIdentity</li><li>acquisitionSignalID</li></ul><p>Each ad event must use matching values for these fields in both SPN and MCCN.</p><h4>SPN: Define the Event and Timing</h4><p>In the SPN document, each ad opportunity is represented by a ResponseSignal.</p><p>Key elements include:</p><ul><li>sig:NPTPoint@nptPoint: The presentation timestamp in seconds within the output asset.</li><li>sig:SCTE35PointDescriptor: The SCTE-35 metadata describing the splice command and segmentation type.</li></ul><p>Example of a simplified linear mid-roll at 180 seconds:</p><pre>&lt;ResponseSignal acquisitionPointIdentity=&quot;SSAI-Example&quot;<br> acquisitionSignalID=&quot;2&quot;<br> signalPointID=&quot;180.000&quot;<br> action=&quot;create&quot;&gt;<br> &lt;sig:NPTPoint nptPoint=&quot;180.000&quot;/&gt;<br> &lt;sig:SCTE35PointDescriptor spliceCommandType=&quot;06&quot;&gt;<br> &lt;sig:SegmentationDescriptorInfo segmentEventId=&quot;201&quot;<br> segmentTypeId=&quot;52&quot;<br> upidType=&quot;0&quot;/&gt;<br> &lt;/sig:SCTE35PointDescriptor&gt;<br>&lt;/ResponseSignal&gt;</pre><p>The nptPoint value determines when the ad opportunity appears in the stream.</p><h4>MCCN: Define the HLS Tags</h4><p>The MCCN document references the same identifiers and specifies which HLS tags are inserted.</p><p>Example for a linear ad opportunity:</p><pre>&lt;ns2:ManifestResponse acquisitionPointIdentity=&quot;SSAI-Example&quot;<br> acquisitionSignalID=&quot;2&quot;&gt;<br> &lt;ns2:SegmentModify&gt;<br> &lt;ns2:FirstSegment&gt;<br> &lt;ns2:Tag value=&quot;#EXT-X-CUE-OUT:0&quot;/&gt;<br> &lt;ns2:Tag value=&quot;#EXT-X-CUE-IN&quot;/&gt;<br> &lt;/ns2:FirstSegment&gt;<br> &lt;/ns2:SegmentModify&gt;<br>&lt;/ns2:ManifestResponse&gt;</pre><p>Important considerations:</p><ul><li>The combination of acquisitionPointIdentity and acquisitionSignalID must match the corresponding SPN entry.</li><li>The nptPoint in SPN controls timing.</li><li>MCCN determines which tags are written into the HLS playlist.</li></ul><h4>Why #EXT-X-CUE-OUT:0 Is Critical for VOD</h4><p>For VOD workflows with MediaTailor:</p><ul><li>Use #EXT-X-CUE-OUT:0 at the start of the break.</li><li>Use #EXT-X-CUE-IN at the end of the break</li></ul><p>If a non-zero duration is used, for example:</p><pre>#EXT-X-CUE-OUT:30</pre><p>MediaTailor interprets “30” as <strong>the amount of main content to be replaced by ads</strong>. In VOD, this can result in unintended skipping of original content.</p><p>Using #EXT-X-CUE-OUT:0 allows MediaTailor to:</p><ul><li>Treat the marker as an ad opportunity of flexible duration</li><li>Insert an ad pod whose length is determined by GAM and selected creatives</li><li>Resume content cleanly at #EXT-X-CUE-IN</li></ul><p>For dynamic SSAI, zero-duration cue-out markers provide the most predictable behavior.</p><h4><strong>Practical Flow in a Typical Pipeline</strong></h4><p>A common implementation follows this pattern:</p><ol><li>An AWS Lambda function analyzes the input asset and determines ad break placement, for example every 20 minutes.</li><li>It generates SPN and MCCN XML documents with:<br>– nptPoint values at the chosen timestamps<br>– Matching identifiers<br>– #EXT-X-CUE-OUT:0 and #EXT-X-CUE-IN tags</li><li>MediaConvert transcodes the asset into an adaptive bitrate HLS ladder.</li><li>ESAM processing inserts the defined tags into the media playlists.</li><li>The resulting HLS output is stored in Amazon S3 and used by MediaTailor as the origin.</li></ol><p>To reproduce this workflow in detail, the ESAM deep-dive article includes:</p><ul><li>Complete SPN and MCCN XML samples for linear and overlay events</li><li>A validation checklist for identifiers, timing, and segment alignment</li><li>Common error patterns and practical remediation steps</li></ul><h4>MediaTailor VOD Limitations and the Role of Client-Side Overlays</h4><p>For VOD workflows, AWS Elemental MediaTailor is well suited for:</p><ul><li>Server-side stitched linear ads, including pre-roll, mid-roll, and post-roll</li><li>Per-viewer manifest personalization</li><li>Emitting metadata tracks that signal ad break boundaries</li></ul><p>However, its scope is intentionally limited.</p><p>For VOD specifically:</p><ol><li>It does not insert overlay or other nonlinear ads into the stream.</li><li>It does not render HTML banners or UI elements. It only stitches media segments into HLS manifests.</li></ol><p>If the monetization strategy includes:</p><ul><li>Lower-third banners</li><li>Companion overlays synchronized with content</li><li>Clickable promotional cards</li></ul><p>These must be implemented on the client side.</p><h4>Recommended Responsibility Split</h4><p>A common pattern is to:</p><ul><li>Keep MediaTailor and Google Ad Manager responsible for all linear SSAI.</li><li>Build a separate overlay pipeline on the client using either:<br>– Custom HLS tags from MediaConvert, for example #EXT-X-OVERLAY-AD:ID=”1&quot;,DURATION=5.0<br>– The Google Interactive Media Ads SDK with a dedicated nonlinear GAM tag</li></ul><h4>Client-Side Nonlinear Ads with Google IMA (Overview)</h4><h4>Separate GAM Tag for Nonlinear Ads</h4><p>For client-side overlays, use the standard Google Ad Manager endpoint:</p><ul><li>Host: pubads.g.doubleclick.net</li><li>VAST type: <strong>nonlinear</strong> via vad_type=nonlinear</li></ul><p>Example tag used in the reference implementation:</p><pre>https://pubads.g.doubleclick.net/gampad/ads?iu=/12345678900/Ad-Unit-Name&amp;description_url=https://domain.com/video&amp;tfcd=0&amp;npa=0&amp;sz=640x480&amp;gdfp_req=1&amp;unviewed_position_start=1&amp;output=vast&amp;env=vp&amp;vpmute=0&amp;vpa=click&amp;vad_type=nonlinear</pre><p>Notes:</p><ul><li>iu= and sz= should match the SSAI configuration so the same line items can target both linear and nonlinear inventory.</li><li>vad_type=nonlinear ensures only overlay or companion creatives are returned.</li><li>description_url= is defined by the frontend. MediaTailor session variables are not used here.</li></ul><h4>Overlay Ad Architecture (High-Level)</h4><p>The overlay system can be separated into three layers.</p><ol><li><strong>Detection Layer<br></strong>– Parses the HLS manifest generated by MediaTailor.<br>– Extracts custom tags such as #EXT-X-OVERLAY-AD:ID=”1&quot;,DURATION=5.0.<br>– Builds an internal schedule of overlay opportunities based on marker timing and duration.</li><li><strong>Resolution Layer<br></strong>– Uses the Google IMA SDK.<br>– For each overlay marker, prefetches a nonlinear ad using an AdsRequest constructed from the dedicated nonlinear GAM tag.<br>– Stores an AdsManager instance per marker so it is ready when playback reaches the scheduled time.</li><li><strong>Presentation Layer<br></strong>– Integrates with the video player, for example Video.js.<br>– When playback enters an overlay window:<br>— Displays a fixed overlay container above the video.<br>— Starts the corresponding AdsManager, allowing IMA to render into that container.<br>– After the configured marker duration (for example 5 seconds), stops the ad and hides the container.</li></ol><p>This overlay path is fully decoupled from AWS Elemental MediaTailor. MediaTailor remains responsible for stream-based linear ads, while the client handles all UI-driven nonlinear formats.</p><h3>Enforcing Non-Skippable Linear Ad Breaks (Optional but Recommended)</h3><p>In VOD workflows, even when linear ads are stitched server-side by AWS Elemental MediaTailor, viewers can still seek past ad breaks unless the player enforces restrictions.</p><p>A practical client-side approach includes:</p><ul><li>Reading MediaTailor’s metadata track, for example a TextTrack labeled ad-cues in Video.js.</li><li>Extracting ad break start and end times from the cue data.</li><li>Implementing a lightweight state machine to:<br>– Detect whether playback is currently inside an ad break.<br>– Disable seek controls while the break is active.<br>– Reject or clamp seek attempts that jump beyond an unplayed ad break.<br>– Re-enable seeking once the break has completed.</li></ul><p>This logic operates entirely in the player layer. It does not modify how MediaTailor requests ads from Google Ad Manager, but it ensures that stitched linear ads cannot be bypassed through scrubbing.</p><p>For monetized VOD environments, this enforcement layer is often required to maintain delivery guarantees and revenue integrity within an SSAI architecture.</p><h3>Request Flows: End-to-End</h3><p>This section summarizes how the system operates from VOD preparation through playback, covering both linear SSAI and client-side overlays.</p><h4>1. Initial VOD Preparation</h4><ol><li>A mezzanine file is uploaded to an Amazon S3 ingest bucket.</li><li>AWS Lambda:<br>– Computes duration using MediaInfo.<br>– Generates SPN and MCCN ESAM XML with:<br>— ResponseSignal entries at chosen times.<br>— Matching ManifestResponse entries with #EXT-X-CUE-OUT:0 and #EXT-X-CUE-IN.<br>– Boots a MediaConvert job using those ESAM files.</li><li>MediaConvert:<br>– Transcodes VOD into an HLS ABR ladder.<br>– Writes ad markers into the HLS.</li><li>The output HLS is stored in a media output S3 bucket and served via CloudFront and Cloudflare.</li></ol><h4>2. Linear SSAI Playback via MediaTailor + GAM</h4><ol><li>The player requests a MediaTailor VOD session URL for a given asset.</li><li>MediaTailor:<br>– Fetches the origin manifest from S3/CloudFront.<br>– Detects #EXT-X-CUE-OUT:0 / #EXT-X-CUE-IN markers.</li><li>For each ad break, MediaTailor:<br>– Resolves session variables like [session.id] and [session.referer].<br>– Calls the configured GAM SSAI URL on serverside.doubleclick.net with:<br>— ssss=mediatailor<br>— vad_type=linear<br>– iu, sz, and other parameters.<br>– Receives VAST with linear creatives.<br>– Stitches ad segments into a personalized manifest.</li><li>The player plays this personalized manifest:<br>– Ads appear as just more HLS segments.<br>– The user sees seamless transitions between content and ads.</li></ol><h4>3. Overlay (Nonlinear) Ad Flow via IMA + GAM</h4><p>In parallel with linear SSAI:</p><ol><li>The player loads the MediaTailor manifest and parses it for custom overlay tags like: #EXT-X-OVERLAY-AD:ID=”1&quot;,DURATION=5.0</li><li>For each overlay marker, the overlay manager:<br>– Builds an IMA AdsRequest using the <strong>nonlinear</strong> GAM tag (vad_type=nonlinear on pubads.g.doubleclick.net).<br>– Prefetches the ad and stores the AdsManager.</li><li>As playback reaches an overlay marker:<br>– The overlay container appears above the video.<br>– The stored AdsManager is initialized and started.<br>– The overlay remains visible for the marker’s DURATION, regardless of the VAST’s internal durations.</li><li>When the overlay window ends:<br>– Overlay container hides; AdsManager is cleaned up.</li></ol><p>Linear and nonlinear paths remain isolated but share the same GAM ad unit and inventory.</p><h3>Common Pitfalls and How to Avoid Them</h3><h4>1. No Tags in Manifest After Transcode</h4><p><strong>Symptoms:</strong></p><ul><li>#EXT-X-CUE-OUT and #EXT-X-CUE-IN are missing from the output HLS.</li><li>AWS Elemental MediaTailor treats the asset as ad-free content.</li></ul><p><strong>Checklist:</strong></p><ul><li>Every SPN ResponseSignal has a corresponding MCCN ManifestResponse.</li><li>acquisitionPointIdentity and acquisitionSignalID match exactly in both XML files.</li><li>nptPoint values are correct and aligned with segment boundaries.</li><li>The ESAM XML files are properly referenced in the AWS Elemental MediaConvert job configuration.</li></ul><h4>2. Unexpected Content Skipping in VOD</h4><p><strong>Symptoms:</strong></p><ul><li>Portions of primary content disappear around ad breaks.</li></ul><p><strong>Fix:</strong></p><ul><li>Ensure MCCN uses #EXT-X-CUE-OUT:0 for VOD workflows with MediaTailor.</li><li>Any non-zero CUE-OUT value instructs MediaTailor to replace that duration of main content with ads, which can result in unintended skipping.</li></ul><h4>3. GAM Not Returning Ads (or Returning the Wrong Ads)</h4><p><strong>Symptoms:</strong></p><ul><li>Empty VAST responses or fallback behavior in MediaTailor logs.</li><li>Line items serving that do not match expectations.</li></ul><p><strong>Checklist:</strong></p><ul><li>iu= in both SSAI and nonlinear tags matches the configured Google Ad Manager ad unit path.</li><li>sz= matches the creative sizes defined on the ad unit and all relevant line items.</li><li>Line items target the specified ad unit or one of its parent units in the hierarchy.</li><li>At least 30 minutes have passed since recent GAM configuration changes.</li></ul><h4>4. SSAI Calls Failing Due to HTTPS / Endpoint Issues</h4><p><strong>Symptoms:</strong></p><ul><li>MediaTailor logs indicate connection failures or SSL errors when calling GAM.</li></ul><p><strong>Fixes:</strong></p><ul><li>Confirm that the required AWS Support request to enable GAM SSL access for MediaTailor has been completed.</li><li>Verify that the SSAI endpoint uses:<br> <a href="https://serverside.doubleclick.net/gampad/ads">https://serverside.doubleclick.net/gampad/ads</a></li><li>Ensure all query parameters are properly URL-encoded.</li></ul><h4>5. Overlay Ads Never Showing Up</h4><p><strong>Symptoms:</strong></p><ul><li>Nonlinear line items are active in GAM, but no overlays appear in the player.</li></ul><p><strong>Checklist:</strong></p><ul><li>The HLS manifest generated by MediaTailor contains overlay markers, for example #EXT-X-OVERLAY-AD.</li><li>The overlay manager parses these tags and issues IMA requests per marker.</li><li>The IMA ad tag uses vad_type=nonlinear and the correct iu and sz parameters.</li><li>The overlay container exists in the DOM and is not hidden by CSS or stacking context issues.</li></ul><h3>Conclusion</h3><p>Connecting AWS Elemental MediaTailor to Google Ad Manager as an Ad Decision Server for VOD provides a structured and scalable monetization workflow, provided each layer is configured precisely.</p><p>Key requirements include:</p><ul><li>MediaTailor relies on correctly formed VOD ad markers, typically generated with AWS Elemental MediaConvert and ESAM.</li><li>GAM must be configured specifically for SSAI traffic using:<br>– serverside.doubleclick.net<br>– ssss=mediatailor<br>– vad_type=linear</li><li>For VOD, #EXT-X-CUE-OUT:0 must be paired with #EXT-X-CUE-IN to prevent unintended replacement of main content.</li><li>Overlay formats are not handled by MediaTailor and require a client-side nonlinear pipeline built around manifest parsing, the Google Interactive Media Ads SDK, and a dedicated GAM tag.</li></ul><p>This architecture creates a clear separation of responsibilities:</p><ul><li>MediaTailor and GAM manage deterministic, cache-friendly linear SSAI for VOD.</li><li>The client, IMA, and GAM handle overlays and companion formats within the presentation layer.</li></ul><p>With this foundation in place, the system can be extended through more advanced GAM targeting strategies, richer overlay implementations, and additional client-side controls such as ad-break seek enforcement or custom analytics, without altering the core SSAI integration.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=664951248cab" width="1" height="1" alt=""><hr><p><a href="https://medium.com/trackit/connecting-aws-mediatailor-to-google-ad-manager-for-vod-ssai-664951248cab">Connecting AWS MediaTailor to Google Ad Manager for VOD SSAI</a> was originally published in <a href="https://medium.com/trackit">TrackIt</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>