The Use Case: Creative + Compliance

In digital advertising, creating engaging ads is just one part of the puzzle. Ensuring that they meet platform policies, regional laws, and internal standards is equally crucial. Manual validation can be slow and inconsistent.

We built an AI workflow that:

• Generated ad creatives based on product metadata
• Evaluated language and imagery against policy constraints
• Validated keywords against geo-specific blacklists
• Logged compliance results and flagged human review if needed

LangChain + LangGraph = Modular AI Workflows

LangChain gave us the tools to define structured prompts, while LangGraph helped orchestrate multi-step workflows.

Key components:

• PromptTemplates: Tailored inputs to different ad formats
• Agents: Coordinated decision-making for generation vs validation
• Chains: Linear and branching workflows to support conditional logic

Example:

1. Agent A generates a creative.
2. Agent B checks it against legal guidelines.
3. Agent C classifies the tone.
4. Results logged into DynamoDB for traceability.

Why LLMs? Why Not Rules?

LLMs offer flexibility and nuance. Rules are great for black-and-white checks, but LLMs can:

• Interpret vague language
• Understand cultural tone
• Generalize compliance patterns across campaigns

We combined LLMs with traditional checks for a hybrid system.

Trust but Verify: Human-in-the-Loop

Not every decision can or should be automated. Our workflow tagged outputs with confidence levels:

• High-confidence passes went live automatically
• Medium-confidence items were flagged for review
• Low-confidence or contradictory results were discarded

Integration with AWS Stack

Our AI workflow was just one part of a larger system:

• Lambda triggered the chain
• S3 stored generated creatives
• Step Functions coordinated between LLMs, validations, and human feedback queues

This allowed us to deploy AI within our already-compliant AWS infrastructure.

Challenges Faced

• LLM hallucinations: Mitigated by strong prompt design and output verification
• Latency: Parallelized checks using LangGraph
• Auditability: Every AI decision logged with inputs and outputs

Key Benefits

• Faster time-to-market for new campaigns
• Fewer compliance errors and regulatory issues
• AI-assisted creativity that adapted to new guidelines without retraining

Conclusion

This project demonstrated that AI can go beyond generation and contribute to governance. LangChain and LangGraph enabled us to build modular, verifiable workflows where creativity and compliance coexisted. The future of AI in operations is not just about output but about trustworthy, auditable systems that evolve with regulations.

The Challenge: Latency Meets Throughput

The AdTech domain demands a unique balance of speed and scale. Platforms must ingest and evaluate thousands of bid requests per second. Any system delay can translate into missed opportunities and revenue loss.

Our goals were:

• <10ms end-to-end latency for processing ad events
• Scalable infrastructure to handle unpredictable spikes in traffic
• Fault tolerance and graceful degradation
• Observability for system health and debugging

Architectural Overview

We chose AWS for its mature serverless ecosystem and cost-efficiency under bursty loads. Here's a breakdown of our architecture:

• AWS Lambda for stateless, on-demand compute
• AWS Step Functions to coordinate multi-step workflows
• Amazon SQS for decoupling producers and consumers
• CloudWatch for metrics, logging, and alerts
• AWS CDK/SAM for Infrastructure-as-Code (IaC)

Lambda functions ingested the traffic, processed requests in parallel, and passed metadata via SQS to a state machine that performed downstream validations and analytics logging.

Why Event-Driven Architecture?

Event-driven systems scale naturally under load. By decoupling components via queues and triggering compute on events, you eliminate idle resources and optimize compute cost. The asynchronous design also allowed us to batch certain operations for downstream analytics.

Benefits:

• Automatic scaling with Lambda
• Built-in retry policies
• Easier reasoning about system boundaries

Infrastructure-as-Code: Enabling Repeatability

To ensure consistent deployments and version control, we relied on AWS CDK and SAM. This enabled us to:

• Roll back to known-good configurations
• Deploy full infrastructure from scratch in dev/test environments
• Track changes across infrastructure code

Observability: The Silent Hero

You can't fix what you can't see. Our observability stack included:

• Structured JSON logs (parsed by CloudWatch Insights)
• Custom metrics for latency, error rates, and queue depth
• Alarms and dashboards to monitor SLAs

When latency spiked, we used structured logs to identify whether a specific event type, downstream service, or data condition was at fault.

Resilience: Embracing Failure

We baked in resilience with the following tactics:

• Automated retries with exponential backoff
• Fallback logic in Lambda to cache stale results if a downstream service failed
• Dead Letter Queues (DLQs) for tracking and remediating failed events

Cost Considerations

One of the overlooked benefits of serverless is cost granularity. With proper memory tuning and cold-start minimization, our entire pipeline cost just a few hundred dollars per month while supporting millions of events.

We also used reserved concurrency and regional settings to avoid hitting throttling limits.

Lessons Learned

• Cold-starts matter: Keep Lambdas warm with scheduled pings if ultra-low latency is critical.
• Time-bound retries: Avoid retry storms by limiting how long retries are allowed.
• Use IaC from day one: It pays dividends in every stage of development.

Final Thoughts

Designing this real-time system gave me hands-on insights into cloud-native scalability and fault-tolerance. More importantly, it reinforced that performance isn't just about faster code—it's about intelligent architecture. If you're working in AdTech or any domain where real-time decisions are vital, consider embracing event-driven pipelines and serverless patterns.

Problems Worth Solving

• Unstructured, video-based site footage not indexed or searchable
• Contractor documents subject to regional standards
• Internal tooling lacked role-based access control (RBAC)

We set out to change this using Python, FastAPI, Docker, and PostgreSQL.

Secure Access via RBAC

First, we built a fine-grained permission system using FastAPI and PostgreSQL. Engineers, auditors, and contractors had different access scopes.

Security Features:

• JWT-based auth
• Granular roles (e.g., "Site Supervisor" vs "Regulatory Auditor")
• SQLAlchemy policies for row-level data filtering

This system allowed us to safely expose internal tools to different stakeholders without compromising sensitive information.

Automating Compliance: Rule Engines in Python

To validate contractor documents against regulatory standards, we developed a Python-based rule engine.

Capabilities:

• Read document metadata and content
• Apply evolving JSON rulesets
• Validate expiration dates, certifications, and formatting

This engine ran nightly over new uploads and flagged inconsistencies before they became liabilities.

Working with Video: Dockerized Pipelines

Construction sites often use time-lapse cameras or drones. We built a video ingestion and indexing pipeline:

• Ingest footage into S3-compatible storage
• Extract frames and embed metadata (timestamp, location)
• Serve processed assets via lightweight REST API

We containerized this pipeline for consistent deployment across edge and cloud environments.

Deploying AFFiNE + CI/CD

For cross-team documentation and collaboration, we deployed AFFiNE in a secure, self-hosted environment. Our CI/CD pipeline ensured:

• Versioned documentation updates
• Markdown-first, user-editable guides
• Access control using OAuth

This became our internal wiki, integrated into onboarding and compliance processes.

ML-Adjacent, Not ML-Dependent

Though we didn't deploy deep models here, our pipeline was ML-friendly:

• Preprocessed data for future computer vision analysis
• Structured logs for anomaly detection models
• Rule engines that could be augmented with classifiers

We laid the foundation for future ML integration.

Conclusion

Construction tech needs more than flashy dashboards—it needs robust backends that process real-world, unstructured data. Our work focused on enabling that. With automation, access control, and modular pipelines, we brought intelligence to an industry that's just beginning its digital journey.