
At Mercury, we built systems to calculate and distribute 1099 interest payouts for thousands of business customers. Accurate tax reporting is critical-mistakes can result in penalties and customer complaints.

#### The Requirements

1099-INT forms require:
- Accurate interest calculations
- Proper tax year reporting
- Customer information (SSN/EIN)
- Compliance with IRS regulations
- Timely filing (by January 31)

#### Architecture

We built:
- **Calculation engine**: Python service to calculate interest
- **Data pipeline**: Extract, transform, load (ETL) for tax data
- **Form generation**: Create 1099-INT PDFs
- **Filing system**: Submit to IRS and states
- **Customer portal**: Allow customers to download forms

#### Interest Calculation

```python
from decimal import Decimal
from datetime import datetime, timedelta

def calculate_interest(
    principal: Decimal,
    annual_rate: Decimal,
    start_date: datetime,
    end_date: datetime
) -> Decimal:
    """
    Calculate interest using daily compounding.
    """
    days = (end_date - start_date).days
    daily_rate = annual_rate / Decimal('365')
    
    # Simple interest calculation
    interest = principal * daily_rate * Decimal(str(days))
    
    return interest.quantize(Decimal('0.01'))

def calculate_annual_interest(
    account_id: str,
    year: int
) -> Decimal:
    """
    Calculate total interest for a tax year.
    """
    transactions = get_interest_transactions(account_id, year)
    
    total_interest = Decimal('0')
    for transaction in transactions:
        if transaction.type == 'interest_payment':
            total_interest += transaction.amount
    
    return total_interest
```

#### Data Pipeline

```python
import pandas as pd

def prepare_1099_data(year: int) -> pd.DataFrame:
    """
    Prepare data for 1099-INT forms.
    """
    # Fetch all accounts with interest
    accounts = get_accounts_with_interest(year)
    
    data = []
    for account in accounts:
        interest = calculate_annual_interest(account.id, year)
        
        if interest > Decimal('10'):  # IRS threshold
            data.append({
                'account_id': account.id,
                'customer_name': account.customer_name,
                'tax_id': account.tax_id,  # SSN or EIN
                'interest_amount': float(interest),
                'year': year,
            })
    
    return pd.DataFrame(data)
```

#### Form Generation

```python
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

def generate_1099_form(customer_data: dict) -> bytes:
    """
    Generate 1099-INT PDF form.
    """
    buffer = io.BytesIO()
    c = canvas.Canvas(buffer, pagesize=letter)
    
    # Form fields
    c.drawString(100, 700, f"PAYER'S name: {customer_data['payer_name']}")
    c.drawString(100, 680, f"RECIPIENT'S name: {customer_data['customer_name']}")
    c.drawString(100, 660, f"Tax ID: {customer_data['tax_id']}")
    c.drawString(100, 640, f"Interest income: ${customer_data['interest_amount']:.2f}")
    
    c.save()
    buffer.seek(0)
    return buffer.read()
```

#### Compliance

- Verify tax IDs (SSN/EIN format)
- Handle backup withholding
- Report to IRS and states
- Maintain records for 7 years
- Handle corrections and amendments

#### Testing

```python
def test_interest_calculation():
    principal = Decimal('10000')
    rate = Decimal('0.05')  # 5%
    start = datetime(2023, 1, 1)
    end = datetime(2023, 12, 31)
    
    interest = calculate_interest(principal, rate, start, end)
    expected = Decimal('500.00')
    
    assert abs(interest - expected) < Decimal('0.01')
```

#### Results

- Accurate tax reporting for thousands of customers
- Timely filing with IRS
- Reduced manual effort
- Better customer experience
- Compliance with regulations

> "Tax reporting requires precision and attention to detail."

#### Lessons Learned

1. Start early (don't wait until January)
2. Test thoroughly with sample data
3. Handle edge cases (closed accounts, corrections)
4. Communicate with customers proactively
5. Keep detailed audit trails



Building 1099 interest payout systems


After years of working long hours and neglecting physical health, I've learned that regular exercise isn't a luxury-it's a productivity multiplier. The engineers I've worked with who maintain active lifestyles consistently outperform their sedentary peers.

#### The Science

Exercise improves:
- Cognitive function and memory
- Stress management
- Sleep quality
- Energy levels throughout the day

For engineering work that requires deep focus and problem-solving, these benefits compound.

#### My Routine

I've settled into a routine that works:
- Morning runs (3-4x per week) for mental clarity
- Strength training (2x per week) for energy
- Weekend hikes for perspective

The key is consistency, not intensity. Even 20-30 minutes makes a difference.

#### Team Culture

At Heard, we encouraged active lifestyles:
- Flexible schedules for workouts
- Step challenges and fitness goals
- Walking meetings when possible
- No judgment about taking breaks

#### The Business Case

Teams with active lifestyles show:
- Lower burnout rates
- Better problem-solving
- More sustainable productivity
- Higher job satisfaction

#### Practical Tips

1. Schedule exercise like a meeting
2. Start small-even 10 minutes helps
3. Find activities you enjoy
4. Make it social when possible
5. Don't let perfect be the enemy of good

> "You can't code well if you don't feel well."

The best code I've written came after a good run, not after pulling an all-nighter.



How an active lifestyle improves engineering productivity


After years of experience in engineering leadership and fintech, I've learned that active recovery for developers requires careful attention to both technical excellence and human factors.

#### The Challenge

Active recovery for developers is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how active recovery for developers applies to your own work. What can you learn? What can you improve? How can you help others?



Active recovery for developers


At Heard, we built an AI-powered auto-categorization system that reduced manual bookkeeping time by 40%. The system uses Python with machine learning libraries to categorize transactions automatically.

#### The Problem

Mental health professionals spend hours each week categorizing expenses for tax purposes. This is tedious, error-prone work that takes time away from their practice.

#### The Solution

We built a classification system using:
- Scikit-learn for initial models
- Transformers for better accuracy
- FastAPI for the API layer
- PostgreSQL for transaction storage

#### The Architecture

```python
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

class TransactionCategorizer:
    def __init__(self):
        self.vectorizer = TfidfVectorizer()
        self.classifier = MultinomialNB()
    
    def train(self, transactions, categories):
        X = self.vectorizer.fit_transform([t.description for t in transactions])
        self.classifier.fit(X, categories)
    
    def predict(self, transaction):
        X = self.vectorizer.transform([transaction.description])
        return self.classifier.predict(X)[0]
```

#### Results

- 40% reduction in manual categorization time
- 92% accuracy on common categories
- Continuous learning from user corrections
- Significant user satisfaction improvement

#### Lessons Learned

1. Start with simple models, iterate based on feedback
2. User corrections are valuable training data
3. Explainability matters-users need to trust the system
4. Handle edge cases gracefully

> "AI should augment human judgment, not replace it."



AI-powered auto-categorization in accounting software


At Mercury, we built an automated reconciliation system that reduced manual effort by 60%. The system matches transactions between our ledger and partner bank statements automatically, flagging discrepancies for review.

#### The Problem

Manual reconciliation was:
- Time-consuming (hours per day)
- Error-prone (human mistakes)
- Not scalable (more transactions = more time)
- Expensive (high labor costs)

#### The Solution

We built an automated system using:
- Python for data processing
- Pandas for matching logic
- PostgreSQL for transaction storage
- Scheduled jobs for daily reconciliation
- Alerting for discrepancies

#### Matching Algorithm

```python
import pandas as pd
from decimal import Decimal

def reconcile_transactions(
    ledger_transactions: pd.DataFrame,
    bank_statement: pd.DataFrame
) -> pd.DataFrame:
    """
    Match transactions between ledger and bank statement.
    """
    # Normalize amounts
    ledger_transactions['amount_abs'] = ledger_transactions['amount'].abs()
    bank_statement['amount_abs'] = bank_statement['amount'].abs()
    
    # Match by amount and date (within 2 days)
    matches = pd.merge_asof(
        ledger_transactions.sort_values('date'),
        bank_statement.sort_values('date'),
        left_on='date',
        right_on='date',
        by='amount_abs',
        tolerance=pd.Timedelta('2 days'),
        direction='nearest'
    )
    
    # Find unmatched transactions
    matched_ledger_ids = matches['ledger_id'].dropna()
    unmatched_ledger = ledger_transactions[
        ~ledger_transactions['id'].isin(matched_ledger_ids)
    ]
    
    matched_bank_ids = matches['bank_id'].dropna()
    unmatched_bank = bank_statement[
        ~bank_statement['id'].isin(matched_bank_ids)
    ]
    
    return {
        'matched': matches.dropna(),
        'unmatched_ledger': unmatched_ledger,
        'unmatched_bank': unmatched_bank,
    }
```

#### Handling Edge Cases

- **Timing differences**: Transactions posted on different days
- **Fees**: Bank fees not in our ledger
- **Reversals**: Failed transactions that were reversed
- **Duplicates**: Same transaction appearing twice
- **Rounding**: Small differences due to rounding

#### Automation

```python
from apscheduler.schedulers.blocking import BlockingScheduler

def daily_reconciliation():
    """Run reconciliation daily at 2 AM."""
    ledger = fetch_ledger_transactions()
    bank_statement = fetch_bank_statement()
    
    results = reconcile_transactions(ledger, bank_statement)
    
    # Alert on discrepancies
    if len(results['unmatched_ledger']) > 0:
        send_alert('Unmatched ledger transactions', results['unmatched_ledger'])
    
    if len(results['unmatched_bank']) > 0:
        send_alert('Unmatched bank transactions', results['unmatched_bank'])
    
    # Store results
    save_reconciliation_results(results)

scheduler = BlockingScheduler()
scheduler.add_job(daily_reconciliation, 'cron', hour=2)
scheduler.start()
```

#### Results

- 60% reduction in manual effort
- Faster reconciliation (minutes vs hours)
- Fewer errors
- Better audit trail
- Scalable to more transactions

> "Automation frees up time for higher-value work."

#### Best Practices

1. Start with simple matching rules
2. Iterate based on results
3. Handle edge cases explicitly
4. Log everything for debugging
5. Alert on discrepancies promptly



Automated reconciliation with partner banks


After a decade away from hands-on coding, diving back into Python for payment processing has been both challenging and invigorating. At Mercury, we needed robust pipelines for handling 1099 interest payouts, and Python's ecosystem proved perfect for the job.

#### Why Python for Payments?

Python's data processing libraries-Pandas, NumPy, and the async capabilities of FastAPI-make it ideal for financial data transformations. The type hints in modern Python also help catch errors before they hit production, which is critical when dealing with money.

#### The Pipeline Architecture

We built an event-driven system using Python's asyncio and message queues. Each payment goes through validation, transformation, and reconciliation stages. The key was making each stage idempotent and traceable.

> "When dealing with financial transactions, every operation must be reversible and auditable."

#### Lessons Learned

The biggest challenge wasn't the code itself, but ensuring compliance and audit trails. Python's logging and monitoring libraries made this manageable, but it required discipline in how we structured the code.



Building payment pipelines with Python


At Pangea, we're building real-time FX trading systems that need to handle market data updates, execute trades, and maintain position state. Python's async capabilities combined with proper architecture make this possible.

#### The Challenge

FX trading requires:
- Low latency (milliseconds matter)
- High throughput (thousands of updates per second)
- Reliability (no data loss)
- Consistency (accurate position tracking)

#### Architecture

We use:
- **asyncio** for concurrent processing
- **WebSockets** for real-time market data
- **Redis** for position state
- **PostgreSQL** for persistence
- **Message queues** for order execution

#### Market Data Handler

```python
import asyncio
import websockets
import json

class FXMarketDataHandler:
    def __init__(self):
        self.subscribers = set()
        self.positions = {}
    
    async def handle_market_data(self, websocket, path):
        async for message in websocket:
            data = json.loads(message)
            await self.process_update(data)
            await self.notify_subscribers(data)
    
    async def process_update(self, data):
        # Update positions in Redis
        currency_pair = data['pair']
        rate = data['rate']
        # Process update...
```

#### Performance Considerations

- Use connection pooling
- Batch database writes
- Cache frequently accessed data
- Monitor latency metrics
- Optimize hot paths

#### Lessons Learned

1. Async is essential for real-time systems
2. State management is critical
3. Monitoring and alerting are non-negotiable
4. Test with production-like load
5. Plan for failure scenarios

> "In trading systems, milliseconds matter. But correctness matters more."



Building real-time FX trading systems


After years of experience in engineering leadership and fintech, I've learned that building secure payment apis requires careful attention to both technical excellence and human factors.

#### The Challenge

Building secure payment APIs is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how building secure payment apis applies to your own work. What can you learn? What can you improve? How can you help others?



Building secure payment APIs


Burnout is an epidemic in engineering. After seeing too many talented engineers leave the industry due to burnout, I've made it a priority to build teams and cultures that prevent it rather than just treat it.

#### What is Burnout?

Burnout isn't just being tired. It's a state of emotional, physical, and mental exhaustion caused by prolonged stress. Symptoms include:
- Exhaustion
- Cynicism and detachment
- Reduced performance
- Loss of motivation

#### Root Causes

**1. Unrealistic Expectations**
Deadlines that can't be met, scope creep, constant "urgent" requests.

**2. Lack of Control**
No say in what you work on or how you work.

**3. Insufficient Rewards**
Not feeling valued or compensated fairly.

**4. Breakdown of Community**
Isolation, conflict, lack of support.

**5. Absence of Fairness**
Favoritism, unfair policies, inconsistent treatment.

#### Prevention Strategies

**For Individuals:**
- Set boundaries (work hours, availability)
- Take regular breaks and vacations
- Maintain hobbies and relationships outside work
- Exercise regularly
- Seek help when needed

**For Leaders:**
- Model healthy behavior
- Set realistic expectations
- Provide autonomy and control
- Recognize and reward good work
- Create psychological safety
- Encourage time off
- Monitor team health

**For Organizations:**
- Reasonable work hours
- Generous time off policies
- Mental health support
- Clear career paths
- Fair compensation
- Healthy culture

#### Early Warning Signs

Watch for:
- Increased sick days
- Decreased productivity
- Negative attitude changes
- Withdrawal from team activities
- Quality issues in work

#### Intervention

If you notice burnout:
1. Have a private conversation
2. Listen without judgment
3. Offer support and resources
4. Adjust workload if possible
5. Check in regularly

#### The Business Case

Preventing burnout:
- Reduces turnover (expensive!)
- Improves productivity
- Increases innovation
- Better code quality
- Higher team morale

> "An ounce of prevention is worth a pound of cure."

Investing in burnout prevention isn't just the right thing to do-it's good business.



Preventing burnout in engineering teams


At lululemon, I led the API-layer team that launched Buy Online, Pick-Up In Store (BOPIS). This feature required real-time inventory synchronization, store location services, and seamless checkout integration.

#### The Challenge

BOPIS requires:
- Real-time inventory visibility
- Store location and availability
- Seamless checkout flow
- Order management system
- Customer notifications

#### Architecture

We built:
- **Inventory API**: Real-time store inventory
- **Location Service**: Store finder and availability
- **Order API**: Create and manage pickup orders
- **Notification Service**: Customer updates
- **Store Integration**: Connect with POS systems

#### Inventory Synchronization

```typescript
class StoreInventoryService {
  async getStoreInventory(
    productId: string,
    storeId: string
  ): Promise<InventoryStatus> {
    // Check cache first
    const cached = await this.cache.get(`inventory:${storeId}:${productId}`);
    if (cached) {
      return cached;
    }
    
    // Fetch from store system
    const inventory = await this.storeSystem.getInventory(storeId, productId);
    
    // Cache for 5 minutes
    await this.cache.set(
      `inventory:${storeId}:${productId}`,
      inventory,
      300
    );
    
    return inventory;
  }
  
  async reserveInventory(
    productId: string,
    storeId: string,
    quantity: number
  ): Promise<ReservationResult> {
    // Reserve inventory in store system
    const reservation = await this.storeSystem.reserve(
      storeId,
      productId,
      quantity
    );
    
    // Invalidate cache
    await this.cache.delete(`inventory:${storeId}:${productId}`);
    
    return reservation;
  }
}
```

#### Store Location Service

```typescript
interface Store {
  id: string;
  name: string;
  address: Address;
  coordinates: Coordinates;
  hours: StoreHours;
  inventory: Map<string, number>;
}

class StoreLocationService {
  async findNearbyStores(
    location: Coordinates,
    radius: number
  ): Promise<Store[]> {
    const stores = await this.storeRepository.findNearby(location, radius);
    
    return stores.map(store => ({
      ...store,
      distance: this.calculateDistance(location, store.coordinates),
    })).sort((a, b) => a.distance - b.distance);
  }
  
  async getStoresWithProduct(
    productId: string,
    location: Coordinates
  ): Promise<Store[]> {
    const stores = await this.findNearbyStores(location, 25); // 25 miles
    
    const availableStores = await Promise.all(
      stores.map(async (store) => {
        const inventory = await this.inventoryService.getStoreInventory(
          productId,
          store.id
        );
        return inventory.available > 0 ? store : null;
      })
    );
    
    return availableStores.filter(Boolean) as Store[];
  }
}
```

#### Order Creation

```typescript
class BOPISOrderService {
  async createPickupOrder(
    customerId: string,
    items: CartItem[],
    storeId: string
  ): Promise<PickupOrder> {
    // Validate store availability
    for (const item of items) {
      const inventory = await this.inventoryService.getStoreInventory(
        item.productId,
        storeId
      );
      
      if (inventory.available < item.quantity) {
        throw new InsufficientInventoryError(item.productId, storeId);
      }
    }
    
    // Reserve inventory
    const reservations = await Promise.all(
      items.map(item =>
        this.inventoryService.reserveInventory(
          item.productId,
          storeId,
          item.quantity
        )
      )
    );
    
    // Create order
    const order = await this.orderRepository.create({
      customerId,
      storeId,
      items,
      type: 'pickup',
      status: 'pending',
      reservations: reservations.map(r => r.id),
    });
    
    // Send notifications
    await this.notificationService.sendOrderConfirmation(order);
    
    return order;
  }
}
```

#### Results

- Successful BOPIS launch
- Real-time inventory accuracy
- Seamless customer experience
- Increased store foot traffic
- Better inventory utilization

> "BOPIS bridges online and physical retail."

#### Lessons Learned

1. Real-time inventory is critical
2. Cache aggressively but invalidate properly
3. Handle inventory conflicts gracefully
4. Provide clear customer communication
5. Monitor store fulfillment rates



Building Buy Online, Pick-Up In Store at lululemon


At Pangea, we use Cloud Build and GitHub Actions for CI/CD. The pipeline builds, tests, and deploys our services automatically, ensuring quality and speed.

#### Pipeline Stages

1. **Lint**: Check code style
2. **Test**: Run unit and integration tests
3. **Build**: Create Docker images
4. **Security Scan**: Check for vulnerabilities
5. **Deploy**: Deploy to staging/production

#### GitHub Actions Workflow

```yaml
name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run linter
        run: npm run lint
      
      - name: Run tests
        run: npm test
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Build Docker image
        run: |
          docker build -t gcr.io/${{ secrets.GCP_PROJECT }}/api:${{ github.sha }} .
      
      - name: Push to GCR
        run: |
          echo "${{ secrets.GCP_SA_KEY }}" | docker login -u _json_key --password-stdin https://gcr.io
          docker push gcr.io/${{ secrets.GCP_PROJECT }}/api:${{ github.sha }}

  deploy-staging:
    needs: build
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to staging
        run: |
          gcloud run deploy api \
            --image gcr.io/${{ secrets.GCP_PROJECT }}/api:${{ github.sha }} \
            --region us-central1 \
            --platform managed
```

#### Cloud Build Configuration

```yaml
# cloudbuild.yaml
steps:
  # Build
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/api:$SHORT_SHA', '.']
  
  # Test
  - name: 'gcr.io/cloud-builders/docker'
    args: ['run', '--rm', 'gcr.io/$PROJECT_ID/api:$SHORT_SHA', 'npm', 'test']
  
  # Security scan
  - name: 'gcr.io/cloud-builders/docker'
    args: ['run', '--rm', '-v', '/var/run/docker.sock:/var/run/docker.sock', 'aquasec/trivy', 'image', 'gcr.io/$PROJECT_ID/api:$SHORT_SHA']
  
  # Push
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'gcr.io/$PROJECT_ID/api:$SHORT_SHA']
  
  # Deploy
  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
    entrypoint: gcloud
    args:
      - 'run'
      - 'deploy'
      - 'api'
      - '--image'
      - 'gcr.io/$PROJECT_ID/api:$SHORT_SHA'
      - '--region'
      - 'us-central1'

images:
  - 'gcr.io/$PROJECT_ID/api:$SHORT_SHA'
```

#### Best Practices

- Fast feedback (fail fast)
- Parallel jobs when possible
- Cache dependencies
- Security scanning
- Automated rollback
- Deployment approvals for production

> "CI/CD enables rapid, reliable deployments."

#### Lessons Learned

1. Keep pipelines fast
2. Test thoroughly
3. Scan for security issues
4. Automate everything possible
5. Monitor deployments



CI/CD with Cloud Build and GitHub Actions


At Cloudentity, I built customer identity and access management (CIAM) products for Fortune 500 clients. The systems handled authentication, authorization, and user management at scale using Scala and React.

#### The Challenge

CIAM systems must:
- Scale to millions of users
- Support multiple authentication methods
- Provide fine-grained authorization
- Comply with security standards
- Integrate with existing systems

#### Architecture

We built:
- **Authentication Service**: Handle logins, SSO, MFA
- **Authorization Engine**: Policy-based access control
- **User Management**: CRUD operations for users
- **Session Management**: Token generation and validation
- **Admin Console**: React-based management UI

#### Authentication Service (Scala)

```scala
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.model.StatusCodes

class AuthenticationService {
  def authenticate(credentials: Credentials): Future[AuthResult] = {
    credentials match {
      case UsernamePassword(username, password) =>
        authenticatePassword(username, password)
      case Token(token) =>
        validateToken(token)
      case SAMLAssertion(assertion) =>
        validateSAMLAssertion(assertion)
    }
  }
  
  private def authenticatePassword(
    username: String,
    password: String
  ): Future[AuthResult] = {
    for {
      user <- userRepository.findByUsername(username)
      isValid <- passwordService.verify(password, user.passwordHash)
    } yield {
      if (isValid) {
        val token = tokenService.generate(user)
        AuthResult.Success(token, user)
      } else {
        AuthResult.Failure("Invalid credentials")
      }
    }
  }
}
```

#### Authorization Engine

```scala
case class Policy(
  subject: String,
  resource: String,
  action: String,
  conditions: List[Condition]
)

class AuthorizationEngine {
  def authorize(
    user: User,
    resource: String,
    action: String
  ): Future[Boolean] = {
    val policies = policyRepository.findBySubject(user.id)
    
    policies.foldLeft(Future.successful(false)) { (acc, policy) =>
      acc.flatMap { authorized =>
        if (authorized) Future.successful(true)
        else evaluatePolicy(policy, user, resource, action)
      }
    }
  }
  
  private def evaluatePolicy(
    policy: Policy,
    user: User,
    resource: String,
    action: String
  ): Future[Boolean] = {
    val matchesResource = policy.resource == resource || 
                         matchesPattern(policy.resource, resource)
    val matchesAction = policy.action == action || 
                       policy.action == "*"
    val conditionsMet = policy.conditions.forall(_.evaluate(user))
    
    Future.successful(matchesResource && matchesAction && conditionsMet)
  }
}
```

#### React Admin Console

```typescript
function UserManagement() {
  const [users, setUsers] = useState<User[]>([]);
  
  useEffect(() => {
    fetchUsers().then(setUsers);
  }, []);
  
  const createUser = async (userData: CreateUserData) => {
    const user = await api.post('/users', userData);
    setUsers(prev => [...prev, user]);
  };
  
  const updateUser = async (userId: string, updates: UserUpdates) => {
    const user = await api.put(`/users/${userId}`, updates);
    setUsers(prev => prev.map(u => u.id === userId ? user : u));
  };
  
  return (
    <div>
      <UserList users={users} />
      <CreateUserForm onSubmit={createUser} />
    </div>
  );
}
```

#### Security Considerations

- Encrypt sensitive data
- Use secure token storage
- Implement rate limiting
- Log all authentication attempts
- Regular security audits

#### Results

- Scalable to millions of users
- Support for multiple auth methods
- Fine-grained authorization
- Compliance with standards
- Successful Fortune 500 deployments

> "CIAM systems are critical infrastructure."

#### Lessons Learned

1. Security must be built in from the start
2. Scalability requires careful design
3. Policy-based authorization is powerful
4. Good UX is essential for adoption
5. Compliance is non-negotiable



Building customer identity and access management at Cloudentity


I've been cycling for years, and like running, I've noticed a strong correlation between my cycling routine and coding performance. There's something about the rhythm of pedaling that helps my brain process complex problems.

#### Why Cycling?

Cycling provides:
- Low-impact cardio (easier on joints than running)
- Time to think (long rides = deep thinking time)
- Stress relief (endorphins and fresh air)
- Improved focus (better blood flow to brain)

#### My Routine

- **Commute cycling** (when possible): 30-45 minutes
- **Weekend rides**: 20-40 miles
- **Indoor trainer**: When weather is bad

The key is consistency-even short rides help.

#### The Coding Connection

After a ride, I notice:
- Better problem-solving ability
- More creative solutions
- Improved debugging focus
- Less frustration when stuck
- Better code reviews

#### Mental Benefits

Cycling gives me time to:
- Process complex problems
- Think through architecture decisions
- Plan my work
- Reflect on challenges
- Gain perspective

#### Physical Benefits

- Improved cardiovascular health
- Better sleep quality
- More energy throughout the day
- Reduced stress and anxiety
- Better overall mood

#### Practical Tips

1. **Start small**: Even 15-20 minutes helps
2. **Make it convenient**: Keep a bike ready
3. **Find your time**: Morning, lunch, or evening
4. **Mix it up**: Road, trail, or indoor
5. **Track progress**: Use apps to see improvement

#### Team Culture

At work, we encourage:
- Flexible schedules for rides
- Bike-friendly office (if applicable)
- Group rides (when possible)
- No judgment about taking breaks

#### The Hard Truth

It's easy to skip rides when work gets busy. But that's when you need them most. Cycling isn't taking time away from coding-it's investing in your ability to code better.

> "The best solutions come when you're not actively thinking about the problem."

Next time you're stuck on a bug or design decision, try going for a ride. The solution might come when you're focused on something else entirely.



Cycling and coding productivity


At Skillshare, we scaled payments globally by building a decoupled checkout architecture. This allowed us to add new payment providers without modifying core checkout code, supporting 13 new providers across different regions.

#### The Problem

Our original checkout was tightly coupled to Stripe:
- Adding new providers required code changes
- Different regions needed different providers
- Testing was difficult
- Hard to A/B test providers

#### The Solution

We built a decoupled architecture:
- **Checkout service**: Handles UI and user flow
- **Payment abstraction layer**: Provider-agnostic interface
- **Provider adapters**: Implementations for each provider
- **Routing logic**: Select provider based on region/user
- **Unified webhooks**: Normalize provider callbacks

#### Architecture

```typescript
interface PaymentProvider {
  createPaymentIntent(amount: number, currency: string): Promise<PaymentIntent>;
  confirmPayment(paymentId: string): Promise<PaymentResult>;
  handleWebhook(payload: unknown): Promise<WebhookEvent>;
}

class StripeProvider implements PaymentProvider {
  async createPaymentIntent(amount: number, currency: string) {
    const intent = await stripe.paymentIntents.create({
      amount,
      currency,
    });
    return this.normalizePaymentIntent(intent);
  }
}

class PayPalProvider implements PaymentProvider {
  async createPaymentIntent(amount: number, currency: string) {
    const order = await paypal.orders.create({
      purchase_units: [{
        amount: { value: amount.toString(), currency_code: currency },
      }],
    });
    return this.normalizePaymentIntent(order);
  }
}
```

#### Provider Router

```typescript
class PaymentProviderRouter {
  private providers: Map<string, PaymentProvider>;
  
  constructor() {
    this.providers = new Map([
      ['stripe', new StripeProvider()],
      ['paypal', new PayPalProvider()],
      ['adyen', new AdyenProvider()],
      // ... more providers
    ]);
  }
  
  selectProvider(user: User, amount: number, currency: string): PaymentProvider {
    // Route based on region
    if (user.region === 'US') {
      return this.providers.get('stripe');
    } else if (user.region === 'EU') {
      return this.providers.get('adyen');
    } else if (user.region === 'APAC') {
      return this.providers.get('paypal');
    }
    
    // Default fallback
    return this.providers.get('stripe');
  }
}
```

#### Checkout Service

```typescript
class CheckoutService {
  private router: PaymentProviderRouter;
  
  async initiateCheckout(user: User, cart: Cart): Promise<CheckoutSession> {
    const provider = this.router.selectProvider(
      user,
      cart.total,
      cart.currency
    );
    
    const paymentIntent = await provider.createPaymentIntent(
      cart.total,
      cart.currency
    );
    
    return {
      sessionId: generateId(),
      paymentIntentId: paymentIntent.id,
      provider: provider.name,
      clientSecret: paymentIntent.clientSecret,
    };
  }
  
  async confirmPayment(sessionId: string, paymentMethod: PaymentMethod): Promise<PaymentResult> {
    const session = await this.getSession(sessionId);
    const provider = this.router.getProvider(session.provider);
    
    return await provider.confirmPayment(
      session.paymentIntentId,
      paymentMethod
    );
  }
}
```

#### Webhook Normalization

```typescript
class WebhookHandler {
  async handleWebhook(provider: string, payload: unknown): Promise<void> {
    const providerImpl = this.router.getProvider(provider);
    const event = await providerImpl.handleWebhook(payload);
    
    // Normalize to common event format
    const normalizedEvent = this.normalizeEvent(event);
    
    // Process event
    await this.processEvent(normalizedEvent);
  }
  
  private normalizeEvent(event: ProviderWebhookEvent): NormalizedEvent {
    return {
      type: this.mapEventType(event.type),
      paymentId: event.paymentId,
      status: this.mapStatus(event.status),
      amount: event.amount,
      timestamp: event.timestamp,
    };
  }
}
```

#### Benefits

- Easy to add new providers
- Region-specific routing
- A/B testing capabilities
- Better error handling
- Unified monitoring

#### Results

- Added 13 new payment providers
- Expanded to new regions
- Improved conversion rates
- Better user experience
- Reduced checkout friction

> "Decoupling enables flexibility and scale."

#### Lessons Learned

1. Design for extensibility from the start
2. Normalize provider differences
3. Test with multiple providers
4. Monitor provider performance
5. Have fallback providers



Scaling payments globally with decoupled checkout


At Heard, I established engineering KPIs tied to company OKRs, increasing feature delivery velocity by 12% and retention by 15%. The key was aligning engineering metrics with business outcomes.

#### The Problem

Traditional engineering metrics (lines of code, commits, velocity) don't connect to business value. We needed metrics that:
- Align with company goals
- Measure outcomes, not outputs
- Drive the right behaviors
- Are actionable

#### Our Approach

**1. Start with Company OKRs**
Understand what the company is trying to achieve.

**2. Map Engineering Work to OKRs**
Connect engineering initiatives to business outcomes.

**3. Define Measurable KPIs**
Create metrics that track progress toward OKRs.

**4. Review Regularly**
Weekly reviews, monthly deep dives, quarterly planning.

#### Example: User Retention OKR

**Company OKR:**
- Increase user retention by 20%

**Engineering Contribution:**
- Reduce time to value (onboarding)
- Improve product reliability
- Fix critical bugs faster

**Engineering KPIs:**
- Time to first value: < 5 minutes
- Uptime: > 99.9%
- Critical bug resolution: < 4 hours

#### KPI Dashboard

```typescript
interface EngineeringKPIs {
  // Feature Delivery
  featureDeliveryVelocity: number; // features per week
  timeToMarket: number; // days from idea to production
  
  // Quality
  bugRate: number; // bugs per feature
  uptime: number; // percentage
  customerSatisfaction: number; // NPS score
  
  // Team Health
  retention: number; // percentage
  engagement: number; // survey score
  burnoutRisk: number; // calculated metric
}

function calculateKPIs(metrics: Metrics): EngineeringKPIs {
  return {
    featureDeliveryVelocity: calculateVelocity(metrics),
    timeToMarket: calculateTTM(metrics),
    bugRate: calculateBugRate(metrics),
    uptime: calculateUptime(metrics),
    customerSatisfaction: metrics.nps,
    retention: calculateRetention(metrics),
    engagement: metrics.engagementScore,
    burnoutRisk: calculateBurnoutRisk(metrics),
  };
}
```

#### Tracking and Reporting

**Weekly Reviews**
- Review KPIs vs targets
- Identify blockers
- Adjust priorities

**Monthly Deep Dives**
- Analyze trends
- Root cause analysis
- Action planning

**Quarterly Planning**
- Set new KPIs
- Align with company OKRs
- Plan initiatives

#### Results

- 12% increase in feature delivery velocity
- 15% increase in retention
- Better alignment with business goals
- More focused engineering work
- Improved team motivation

> "What gets measured gets managed."

#### Lessons Learned

1. Align metrics with business outcomes
2. Measure outcomes, not outputs
3. Review regularly
4. Adjust based on results
5. Keep it simple

#### Common Pitfalls

- Too many metrics (focus on 5-7)
- Vanity metrics (measure what matters)
- Setting and forgetting (review regularly)
- Ignoring context (understand why metrics change)
- Gaming the system (prevent manipulation)



Establishing engineering KPIs tied to company OKRs


At Pangea, we built event-driven ingestion pipelines using Pub/Sub, Cloud Run, and event sourcing patterns. The system processes financial events reliably and scales automatically.

#### Architecture

```typescript
// Event publisher
class EventPublisher {
  private pubsub: PubSub;
  
  async publishEvent(event: FinancialEvent): Promise<void> {
    const topic = this.pubsub.topic('financial-events');
    await topic.publishMessage({
      json: event,
      attributes: {
        eventType: event.type,
        userId: event.userId,
      },
    });
  }
}

// Event consumer
class EventConsumer {
  private subscription: Subscription;
  
  async start(): Promise<void> {
    this.subscription.on('message', async (message) => {
      try {
        const event = message.json as FinancialEvent;
        await this.processEvent(event);
        message.ack();
      } catch (error) {
        logger.error('Failed to process event', error);
        message.nack();
      }
    });
  }
  
  private async processEvent(event: FinancialEvent): Promise<void> {
    switch (event.type) {
      case 'payment.created':
        await this.handlePaymentCreated(event);
        break;
      case 'transaction.completed':
        await this.handleTransactionCompleted(event);
        break;
      // ... more handlers
    }
  }
}
```

#### Event Sourcing

```typescript
interface Event {
  id: string;
  type: string;
  aggregateId: string;
  data: Record<string, unknown>;
  timestamp: Date;
  version: number;
}

class EventStore {
  async append(aggregateId: string, events: Event[]): Promise<void> {
    // Store events in order
    for (const event of events) {
      await this.store.append(aggregateId, event);
    }
  }
  
  async getEvents(aggregateId: string): Promise<Event[]> {
    return this.store.getEvents(aggregateId);
  }
  
  async replay(aggregateId: string): Promise<AggregateState> {
    const events = await this.getEvents(aggregateId);
    return events.reduce((state, event) => this.applyEvent(state, event), initialState);
  }
}
```

#### Benefits

- Reliable processing
- Automatic scaling
- Event replay capability
- Audit trail
- Loose coupling

> "Event-driven architecture enables reliable, scalable systems."

#### Lessons Learned

1. Design events carefully
2. Handle idempotency
3. Implement proper error handling
4. Monitor event processing
5. Plan for event replay



Event-driven data ingestion at Pangea


After years of experience in engineering leadership and fintech, I've learned that fx market data pipelines requires careful attention to both technical excellence and human factors.

#### The Challenge

FX market data pipelines is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how fx market data pipelines applies to your own work. What can you learn? What can you improve? How can you help others?



FX market data pipelines


I've been hiking for years, but it wasn't until I started connecting my hiking experiences to my engineering work that I realized how much they have in common. Both require planning, persistence, and the ability to adapt when things don't go as expected.

#### The Planning Phase

Before a hike, you:
- Research the trail
- Check weather conditions
- Pack the right gear
- Plan your route
- Tell someone where you're going

Before tackling a complex engineering problem, you should:
- Understand the requirements
- Research existing solutions
- Gather the right tools
- Plan your approach
- Communicate your plan

#### The Journey

On a hike, you:
- Start with energy and enthusiasm
- Encounter obstacles (steep sections, bad weather)
- Adjust your pace
- Take breaks when needed
- Keep moving forward

In engineering:
- Start with clear goals
- Encounter obstacles (bugs, performance issues)
- Adjust your approach
- Take breaks to avoid burnout
- Keep making progress

#### Problem-Solving Parallels

**Breaking Down Big Problems**
A long hike is just a series of steps. A complex system is just a series of smaller problems to solve.

**Persistence**
Sometimes the trail is hard, but you keep going. Sometimes code is frustrating, but you keep debugging.

**Adaptation**
Weather changes? Adjust your plan. Requirements change? Adjust your approach.

**Rest and Recovery**
You can't hike 24/7. You can't code 24/7. Rest makes you stronger.

#### The Summit

Reaching the summit feels amazing. So does shipping a feature that works well. But the real value is in the journey-the skills you develop, the problems you solve, the resilience you build.

#### Lessons for Engineering

1. **Break problems into smaller pieces**
   Just like a hike is a series of steps, a complex system is a series of smaller problems.

2. **Prepare thoroughly**
   Research, plan, gather tools. Preparation prevents problems.

3. **Pace yourself**
   Sprinting works for short distances, but marathons require pacing.

4. **Adapt to conditions**
   Plans change. Requirements change. Be flexible.

5. **Enjoy the journey**
   Not every moment is fun, but the overall experience is rewarding.

#### The Mental Health Angle

Hiking provides:
- Physical exercise
- Time in nature
- Mental clarity
- Stress relief
- Sense of accomplishment

All of these translate to better engineering work.

> "The best solutions come when you step away from the computer and gain perspective."

Next time you're stuck on a problem, try going for a hike. The solution might come when you're not actively thinking about it.



What hiking taught me about problem-solving


At Pangea, we integrated multiple third-party services: Jiko for banking, Plaid for account connectivity, Clerk for authentication, and Xata for data storage. Each integration required careful design and error handling.

#### Integration Architecture

```typescript
// Authentication with Clerk
import { Clerk } from '@clerk/clerk-sdk-node';

class AuthService {
  private clerk: Clerk;
  
  async authenticateUser(token: string): Promise<User> {
    const user = await this.clerk.verifyToken(token);
    return this.mapClerkUserToUser(user);
  }
}

// Account connectivity with Plaid
import { PlaidApi } from 'plaid';

class AccountService {
  private plaid: PlaidApi;
  
  async linkAccount(userId: string): Promise<LinkToken> {
    const response = await this.plaid.linkTokenCreate({
      user: { client_user_id: userId },
      client_name: 'Pangea',
      products: ['transactions', 'auth'],
      country_codes: ['US'],
    });
    
    return response.data.link_token;
  }
}

// Banking with Jiko
class BankingService {
  async createAccount(userId: string, accountData: AccountData): Promise<Account> {
    const response = await fetch('https://api.jiko.com/accounts', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.JIKO_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        user_id: userId,
        ...accountData,
      }),
    });
    
    return response.json();
  }
}

// Data storage with Xata
import { XataClient } from '@xata.io/client';

class DataService {
  private xata: XataClient;
  
  async storeTransaction(transaction: Transaction): Promise<void> {
    await this.xata.db.transactions.create(transaction);
  }
}
```

#### Unified Service Layer

```typescript
class PangeaService {
  constructor(
    private auth: AuthService,
    private accounts: AccountService,
    private banking: BankingService,
    private data: DataService,
  ) {}
  
  async onboardUser(authToken: string, accountData: AccountData): Promise<OnboardingResult> {
    // Authenticate user
    const user = await this.auth.authenticateUser(authToken);
    
    // Create bank account
    const bankAccount = await this.banking.createAccount(user.id, accountData);
    
    // Link Plaid account
    const linkToken = await this.accounts.linkAccount(user.id);
    
    // Store in Xata
    await this.data.storeTransaction({
      userId: user.id,
      accountId: bankAccount.id,
      type: 'onboarding',
    });
    
    return {
      userId: user.id,
      bankAccountId: bankAccount.id,
      linkToken,
    };
  }
}
```

#### Error Handling

```typescript
class IntegrationError extends Error {
  constructor(
    message: string,
    public service: string,
    public code: string,
  ) {
    super(message);
  }
}

async function handleIntegrationError(error: unknown, service: string): Promise<never> {
  if (error instanceof IntegrationError) {
    // Log and handle service-specific errors
    logger.error(`Integration error in ${service}`, error);
    throw error;
  }
  
  // Handle unexpected errors
  logger.error(`Unexpected error in ${service}`, error);
  throw new IntegrationError('Unexpected error', service, 'UNKNOWN');
}
```

#### Testing Integrations

```typescript
describe('PangeaService', () => {
  it('should onboard user successfully', async () => {
    // Mock integrations
    jest.spyOn(authService, 'authenticateUser').mockResolvedValue(mockUser);
    jest.spyOn(bankingService, 'createAccount').mockResolvedValue(mockAccount);
    
    const result = await pangeaService.onboardUser('token', accountData);
    
    expect(result.userId).toBeDefined();
    expect(result.bankAccountId).toBeDefined();
  });
});
```

#### Best Practices

- Use SDKs when available
- Handle errors gracefully
- Implement retries with backoff
- Monitor integration health
- Cache when appropriate
- Document integration contracts

> "Third-party integrations require careful design and error handling."

#### Lessons Learned

1. Use official SDKs
2. Handle all error cases
3. Implement proper retries
4. Monitor integration health
5. Test with sandbox environments



Integrating Jiko, Plaid, Clerk, and Xata at Pangea


After years of experience in engineering leadership and fintech, I've learned that managing engineering stress requires careful attention to both technical excellence and human factors.

#### The Challenge

Managing engineering stress is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how managing engineering stress applies to your own work. What can you learn? What can you improve? How can you help others?



Managing engineering stress


At Cloudentity, I managed an overseas team delivering solutions in Scala and React. Managing distributed teams across time zones requires different skills than managing co-located teams.

#### The Challenges

Distributed teams face:
- Time zone differences
- Cultural differences
- Communication barriers
- Lack of face-to-face interaction
- Coordination overhead

#### What Works

**1. Overlap Hours**
Establish core hours when everyone is available. We had 4 hours of overlap between US and overseas teams.

**2. Async-First Communication**
Default to async (Slack, email, docs) with sync meetings only when necessary.

**3. Clear Documentation**
Write everything down. Don't rely on verbal communication.

**4. Regular Check-ins**
Weekly 1:1s, daily standups, and regular team meetings.

**5. Cultural Awareness**
Understand and respect cultural differences in communication and work styles.

#### Communication Practices

**Daily Standups**
- Async updates in Slack
- Video standup once per week
- Focus on blockers and progress

**Documentation**
- Architecture decisions in ADRs
- API contracts in OpenAPI specs
- Runbooks for operations
- Meeting notes shared immediately

**Code Reviews**
- Clear guidelines and expectations
- Timely reviews (within 24 hours)
- Constructive feedback
- Pair programming when possible

#### Tools

- **Slack**: Daily communication
- **Zoom**: Video meetings
- **GitHub**: Code collaboration
- **Notion**: Documentation
- **Jira**: Project tracking

#### Building Trust

- Be available during overlap hours
- Respond to messages promptly
- Follow through on commitments
- Recognize good work publicly
- Address issues directly

#### Handling Conflicts

- Address issues early
- Use video calls for difficult conversations
- Focus on facts, not assumptions
- Seek to understand different perspectives
- Find win-win solutions

#### Results

- Successful project delivery
- Strong team cohesion
- Good work-life balance for all
- High code quality
- Positive team culture

> "Distance doesn't have to mean disconnection."

#### Lessons Learned

1. Communication is everything
2. Documentation is critical
3. Trust takes time to build
4. Cultural awareness matters
5. Overlap hours are essential



Managing an overseas engineering team


Meditation might seem like the opposite of coding-sitting still versus active problem-solving. But after years of practice, I've found that meditation significantly improves my engineering work: better focus, clearer thinking, and reduced stress.

#### Why Meditation?

Meditation provides:
- Improved focus and concentration
- Reduced stress and anxiety
- Better emotional regulation
- Enhanced creativity
- Improved sleep quality

#### The Science

Research shows meditation:
- Increases gray matter in the brain
- Improves attention and memory
- Reduces cortisol (stress hormone)
- Enhances cognitive flexibility
- Boosts immune function

#### Getting Started

**1. Start Small**
Even 5-10 minutes helps. Don't aim for hour-long sessions initially.

**2. Find Your Time**
Morning works for many, but find what fits your schedule.

**3. Use Apps**
Apps like Headspace, Calm, or Insight Timer provide guided meditations.

**4. Focus on Breath**
Simple breath-focused meditation is a great starting point.

**5. Be Patient**
Your mind will wander. That's normal. Just return to your breath.

#### Simple Practice

1. Sit comfortably (chair or cushion)
2. Close your eyes or soften your gaze
3. Focus on your breath
4. When your mind wanders, gently return to breath
5. Start with 5 minutes, gradually increase

#### For Engineers

Meditation helps with:
- **Debugging**: Clear mind sees problems more clearly
- **Architecture**: Better decision-making
- **Code reviews**: More focused attention
- **Meetings**: Better listening and presence
- **Stress management**: Handle pressure better

#### Common Challenges

**"I can't stop thinking"**
That's normal. The goal isn't to stop thinking-it's to notice thoughts without getting caught in them.

**"I don't have time"**
Start with 5 minutes. The time investment pays off in improved productivity.

**"It doesn't work"**
Give it time. Benefits accumulate over weeks and months.

#### Making It a Habit

- Schedule it like a meeting
- Start small and build gradually
- Use apps for guidance
- Find a community or group
- Be consistent, not perfect

> "Meditation isn't about stopping thoughts-it's about changing your relationship with them."

#### Resources

- Headspace (app)
- Calm (app)
- Insight Timer (app)
- "The Mind Illuminated" (book)
- Local meditation centers

#### The Impact

After consistent practice, I noticed:
- Better focus during deep work
- Less reactivity to stress
- Improved sleep
- More patience with complex problems
- Better work-life balance

Try it for a month. See if it helps your engineering work.



Meditation for engineers


After years of experience in engineering leadership and fintech, I've learned that mental health in fintech requires careful attention to both technical excellence and human factors.

#### The Challenge

Mental health in fintech is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how mental health in fintech applies to your own work. What can you learn? What can you improve? How can you help others?



Mental health in fintech


After years in engineering leadership, I've compiled a list of mental health resources that have helped me and my teams. Mental health is just as important as code quality, and there's no shame in seeking help.

#### Professional Resources

**Therapy and Counseling**
- BetterHelp, Talkspace (online therapy)
- Local therapists (in-person)
- Employee Assistance Programs (EAPs)
- Psychology Today directory

**Crisis Resources**
- National Suicide Prevention Lifeline: 988
- Crisis Text Line: Text HOME to 741741
- International Association for Suicide Prevention

#### Self-Help Tools

**Apps**
- Headspace (meditation)
- Calm (sleep and meditation)
- Mood Meter (emotion tracking)
- Daylio (mood journaling)

**Books**
- "The Body Keeps the Score" by Bessel van der Kolk
- "Maybe You Should Talk to Someone" by Lori Gottlieb
- "The Happiness Trap" by Russ Harris

#### Community Support

- Engineering support groups
- Mental health in tech communities
- Peer support networks
- Online forums (with caution)

#### Workplace Resources

**What to Look For:**
- Mental health benefits
- EAP programs
- Flexible schedules
- Mental health days
- Supportive culture

**What to Ask For:**
- Mental health coverage
- Therapy reimbursement
- Flexible work arrangements
- Reduced workload when needed

#### Self-Care Practices

- Regular exercise
- Adequate sleep
- Healthy eating
- Social connections
- Hobbies and interests
- Time in nature
- Mindfulness practices

#### When to Seek Help

Consider professional help if you experience:
- Persistent sadness or anxiety
- Changes in sleep or appetite
- Difficulty concentrating
- Loss of interest in activities
- Thoughts of self-harm

#### Breaking the Stigma

Talking about mental health normalizes it. As leaders, we can:
- Share our own experiences
- Create safe spaces for discussion
- Provide resources and support
- Model healthy behavior

> "Seeking help is a sign of strength, not weakness."

Your mental health matters. Don't hesitate to reach out for support.



Mental health resources for engineers


Leading engineering teams at Heard, a company supporting mental health professionals, gave me a unique perspective on the intersection of technology and wellbeing. The irony wasn't lost on me: we were building tools for therapists while navigating our own mental health challenges in a high-pressure startup environment.

#### The Stigma Problem

There's still a stigma around discussing mental health in tech leadership. We expect leaders to be unflappable, but the reality is that engineering executives face immense pressure-deadlines, budget constraints, team dynamics, and the constant need to make decisions with incomplete information.

#### Creating Space for Vulnerability

At Heard, we implemented practices that normalized mental health discussions:
- Weekly check-ins that went beyond project status
- Encouraging time off without guilt
- Modeling healthy boundaries ourselves

#### The Business Case

Teams with better mental health support have higher retention, better decision-making, and more sustainable productivity. It's not just the right thing to do-it's good business.

> "You can't pour from an empty cup. Leaders need to model self-care."

#### Practical Steps

1. Normalize therapy and mental health support
2. Create psychological safety for difficult conversations
3. Measure team wellbeing alongside velocity metrics
4. Lead by example in taking breaks and vacations



Mental health in tech leadership


Leading the migration from Heroku to AWS at Heard was one of the most challenging infrastructure projects I've managed. We cut costs by 20% and improved uptime from 97.5% to 99.9%, but the journey was complex.

#### Why Migrate?

Heroku was great for getting started, but as we scaled:
- Costs grew faster than revenue
- Limited control over infrastructure
- Performance bottlenecks
- Compliance requirements needed more control

#### The Migration Strategy

We used a phased approach:
1. **Assessment**: Inventory all services and dependencies
2. **Parallel Run**: Run both environments simultaneously
3. **Gradual Cutover**: Move services one by one
4. **Optimization**: Tune AWS services for cost and performance

#### Key Decisions

**ECS vs EC2**: Chose ECS for container orchestration
**RDS vs Self-Managed**: RDS for managed Postgres
**CloudFront**: For CDN and caching
**Terraform**: Infrastructure as code

#### Challenges

- Database migration was the hardest part
- DNS cutover timing
- Team training on AWS services
- Monitoring and alerting setup

#### Results

- 20% cost reduction
- 99.9% uptime (up from 97.5%)
- Better performance and scalability
- More control over infrastructure

#### Lessons

1. Plan for 2x the time you think you need
2. Test migrations thoroughly in staging
3. Have rollback plans for every step
4. Communicate progress regularly
5. Invest in monitoring from day one

> "A successful migration is one where users don't notice it happened."



Migrating from Heroku to AWS: lessons learned


At Skillshare, we migrated our payments backend to Nest.js and our frontend to React. The migration improved developer experience, type safety, and maintainability.

#### Why Migrate?

Our legacy stack had issues:
- Tight coupling between components
- Limited type safety
- Difficult to test
- Poor developer experience
- Hard to scale

#### Backend: Nest.js Migration

Nest.js provides:
- TypeScript-first architecture
- Dependency injection
- Modular structure
- Built-in testing support
- Excellent documentation

#### Service Structure

```typescript
// payment.service.ts
@Injectable()
export class PaymentService {
  constructor(
    private paymentRepository: PaymentRepository,
    private notificationService: NotificationService,
  ) {}
  
  async processPayment(dto: CreatePaymentDto): Promise<Payment> {
    const payment = await this.paymentRepository.create(dto);
    await this.notificationService.sendConfirmation(payment);
    return payment;
  }
}

// payment.controller.ts
@Controller('payments')
export class PaymentController {
  constructor(private paymentService: PaymentService) {}
  
  @Post()
  async create(@Body() dto: CreatePaymentDto): Promise<Payment> {
    return this.paymentService.processPayment(dto);
  }
}
```

#### Module Organization

```typescript
@Module({
  imports: [TypeOrmModule.forFeature([Payment])],
  controllers: [PaymentController],
  providers: [PaymentService, PaymentRepository],
  exports: [PaymentService],
})
export class PaymentModule {}
```

#### Frontend: React Migration

React provides:
- Component-based architecture
- Strong ecosystem
- TypeScript support
- Great developer tools
- Performance optimizations

#### Component Structure

```typescript
interface PaymentFormProps {
  onSubmit: (payment: PaymentData) => void;
}

function PaymentForm({ onSubmit }: PaymentFormProps) {
  const [paymentData, setPaymentData] = useState<PaymentData>({
    amount: 0,
    currency: 'USD',
  });
  
  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    onSubmit(paymentData);
  };
  
  return (
    <form onSubmit={handleSubmit}>
      <input
        type="number"
        value={paymentData.amount}
        onChange={(e) => setPaymentData({
          ...paymentData,
          amount: parseFloat(e.target.value),
        })}
      />
      <button type="submit">Pay</button>
    </form>
  );
}
```

#### Migration Strategy

1. **Parallel Run**: Run old and new systems side-by-side
2. **Feature Flags**: Gradually enable new system
3. **Incremental Migration**: Move features one at a time
4. **Testing**: Comprehensive testing at each step
5. **Rollback Plan**: Ability to revert if needed

#### Testing

```typescript
// Backend tests
describe('PaymentService', () => {
  let service: PaymentService;
  
  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [PaymentService, PaymentRepository],
    }).compile();
    
    service = module.get<PaymentService>(PaymentService);
  });
  
  it('should process payment', async () => {
    const result = await service.processPayment({
      amount: 100,
      currency: 'USD',
    });
    
    expect(result).toBeDefined();
  });
});

// Frontend tests
describe('PaymentForm', () => {
  it('should submit payment data', () => {
    const onSubmit = jest.fn();
    render(<PaymentForm onSubmit={onSubmit} />);
    
    fireEvent.change(screen.getByLabelText('Amount'), {
      target: { value: '100' },
    });
    fireEvent.click(screen.getByText('Pay'));
    
    expect(onSubmit).toHaveBeenCalledWith({
      amount: 100,
      currency: 'USD',
    });
  });
});
```

#### Results

- Better type safety
- Improved developer experience
- Easier testing
- More maintainable code
- Faster feature development

> "Modern frameworks improve productivity and code quality."

#### Lessons Learned

1. Plan migration carefully
2. Test thoroughly
3. Migrate incrementally
4. Train team on new stack
5. Monitor performance



Migrating to Nest.js and React


Building financial dashboards requires real-time data, complex visualizations, and excellent user experience. Next.js provides the perfect foundation for these applications, combining React's component model with server-side rendering and API routes.

#### Why Next.js?

Next.js offers:
- Server-side rendering for fast initial loads
- API routes for backend logic
- TypeScript support out of the box
- Excellent developer experience
- Great performance optimizations

#### Architecture

We use:
- **Next.js** for the framework
- **TypeScript** for type safety
- **Tailwind CSS** for styling
- **Recharts** or **Chart.js** for visualizations
- **SWR** or **React Query** for data fetching

#### Example: Dashboard Page

```typescript
import { GetServerSideProps } from 'next';
import { useState } from 'react';
import useSWR from 'swr';

interface DashboardProps {
  initialData: FinancialData;
}

export default function Dashboard({ initialData }: DashboardProps) {
  const { data, error } = useSWR('/api/financial-data', {
    fallbackData: initialData,
    refreshInterval: 5000, // Refresh every 5 seconds
  });

  if (error) return <div>Error loading data</div>;
  if (!data) return <div>Loading...</div>;

  return (
    <div className="grid grid-cols-3 gap-4">
      <BalanceCard balance={data.balance} />
      <TransactionList transactions={data.transactions} />
      <Chart data={data.chartData} />
    </div>
  );
}

export const getServerSideProps: GetServerSideProps = async () => {
  const data = await fetchFinancialData();
  return { props: { initialData: data } };
};
```

#### Real-Time Updates

```typescript
function useRealtimeFinancialData() {
  const { data, mutate } = useSWR('/api/financial-data');
  
  useEffect(() => {
    const eventSource = new EventSource('/api/stream');
    eventSource.onmessage = (event) => {
      const newData = JSON.parse(event.data);
      mutate(newData, false); // Update without revalidation
    };
    return () => eventSource.close();
  }, [mutate]);
  
  return data;
}
```

#### Security Considerations

- Authenticate all API routes
- Validate all user inputs
- Use HTTPS in production
- Implement rate limiting
- Sanitize data before display

#### Performance

- Use static generation when possible
- Implement proper caching
- Optimize images
- Code split large components
- Monitor performance metrics

> "Financial dashboards need to be fast, accurate, and secure."

#### Best Practices

1. Type everything with TypeScript
2. Handle loading and error states
3. Implement proper authentication
4. Optimize for performance
5. Test thoroughly



Next.js for financial dashboards


At Elevate Security, we built a no-code workflow builder that allowed users to create security automation workflows without writing code. Built with React and Tailwind, it provided a visual interface for connecting actions and triggers.

#### The Vision

Enable non-technical users to:
- Create workflows visually
- Connect triggers to actions
- Test workflows before deployment
- Monitor workflow execution
- Debug workflow issues

#### Architecture

- **Frontend**: React with drag-and-drop
- **Backend**: Node.js/Express API
- **Execution Engine**: Workflow runner service
- **Storage**: PostgreSQL for workflow definitions
- **Monitoring**: Real-time execution logs

#### React Components

```typescript
import React, { useState } from 'react';
import { ReactFlow, Node, Edge } from 'reactflow';

interface WorkflowNode {
  id: string;
  type: 'trigger' | 'action' | 'condition';
  data: {
    label: string;
    config: Record<string, unknown>;
  };
  position: { x: number; y: number };
}

function WorkflowBuilder() {
  const [nodes, setNodes] = useState<Node[]>([]);
  const [edges, setEdges] = useState<Edge[]>([]);
  
  const onNodesChange = (changes: NodeChange[]) => {
    setNodes(applyNodeChanges(changes, nodes));
  };
  
  const onEdgesChange = (changes: EdgeChange[]) => {
    setEdges(applyEdgeChanges(changes, edges));
  };
  
  const onConnect = (connection: Connection) => {
    setEdges(prev => addEdge(connection, prev));
  };
  
  return (
    <div className="h-screen w-full">
      <ReactFlow
        nodes={nodes}
        edges={edges}
        onNodesChange={onNodesChange}
        onEdgesChange={onEdgesChange}
        onConnect={onConnect}
      >
        <Controls />
        <MiniMap />
        <Background />
      </ReactFlow>
    </div>
  );
}
```

#### Node Types

```typescript
const nodeTypes = {
  trigger: TriggerNode,
  action: ActionNode,
  condition: ConditionNode,
};

function TriggerNode({ data }: { data: NodeData }) {
  return (
    <div className="px-4 py-2 bg-blue-500 text-white rounded">
      <div className="font-bold">{data.label}</div>
      <div className="text-sm">{data.description}</div>
    </div>
  );
}

function ActionNode({ data }: { data: NodeData }) {
  return (
    <div className="px-4 py-2 bg-green-500 text-white rounded">
      <div className="font-bold">{data.label}</div>
      <div className="text-sm">{data.description}</div>
    </div>
  );
}
```

#### Workflow Execution

```typescript
class WorkflowExecutor {
  async executeWorkflow(workflowId: string, context: ExecutionContext): Promise<ExecutionResult> {
    const workflow = await this.loadWorkflow(workflowId);
    const execution = await this.createExecution(workflowId);
    
    try {
      // Execute trigger
      const triggerResult = await this.executeTrigger(workflow.trigger, context);
      
      // Execute actions
      for (const action of workflow.actions) {
        if (await this.evaluateConditions(action.conditions, triggerResult)) {
          await this.executeAction(action, triggerResult);
        }
      }
      
      await this.markExecutionComplete(execution.id);
      return { success: true, executionId: execution.id };
    } catch (error) {
      await this.markExecutionFailed(execution.id, error);
      throw error;
    }
  }
}
```

#### Testing Workflows

```typescript
function WorkflowTester({ workflowId }: { workflowId: string }) {
  const [testResult, setTestResult] = useState<TestResult | null>(null);
  
  const runTest = async () => {
    const result = await fetch(`/api/workflows/${workflowId}/test`, {
      method: 'POST',
      body: JSON.stringify({ testData: {} }),
    }).then(r => r.json());
    
    setTestResult(result);
  };
  
  return (
    <div>
      <button onClick={runTest}>Run Test</button>
      {testResult && (
        <TestResultViewer result={testResult} />
      )}
    </div>
  );
}
```

#### Results

- Non-technical users created workflows
- Faster automation setup
- Visual debugging
- Better user experience
- Reduced support requests

> "No-code tools democratize automation."

#### Lessons Learned

1. Make the UI intuitive
2. Provide good error messages
3. Allow testing before deployment
4. Show execution logs
5. Support workflow versioning



Building a no-code workflow builder with React


After years of experience in engineering leadership and fintech, I've learned that outdoor activities and creativity requires careful attention to both technical excellence and human factors.

#### The Challenge

Outdoor activities and creativity is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how outdoor activities and creativity applies to your own work. What can you learn? What can you improve? How can you help others?



Outdoor activities and creativity


After years of experience in engineering leadership and fintech, I've learned that payment reconciliation automation requires careful attention to both technical excellence and human factors.

#### The Challenge

Payment reconciliation automation is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how payment reconciliation automation applies to your own work. What can you learn? What can you improve? How can you help others?



Payment reconciliation automation


At Ness, we integrated Plaid to streamline onboarding for our consumer credit card platform. The integration reduced onboarding time by 50%, but getting it right required careful attention to TypeScript types and error handling.

#### Why Plaid?

Plaid provides a unified API for connecting to thousands of financial institutions. Instead of building integrations with each bank, we use Plaid's API to access account data, transaction history, and identity verification.

#### The TypeScript Advantage

Plaid's TypeScript SDK provides excellent type safety:

```typescript
import { PlaidApi, PlaidEnvironments, AccountsGetRequest } from 'plaid';

const client = new PlaidApi({
  basePath: PlaidEnvironments.sandbox,
  baseOptions: {
    headers: {
      'PLAID-CLIENT-ID': process.env.PLAID_CLIENT_ID,
      'PLAID-SECRET': process.env.PLAID_SECRET,
    },
  },
});

async function getAccounts(accessToken: string) {
  const request: AccountsGetRequest = {
    access_token: accessToken,
  };
  
  const response = await client.accountsGet(request);
  return response.data.accounts;
}
```

#### Error Handling

Plaid uses specific error codes that we need to handle:

```typescript
try {
  const accounts = await getAccounts(accessToken);
} catch (error) {
  if (error.response?.data?.error_code === 'ITEM_LOGIN_REQUIRED') {
    // Re-authenticate the user
    return redirectToPlaidLink();
  }
  // Handle other errors
}
```

#### Security Considerations

- Never store Plaid access tokens in plain text
- Use environment variables for credentials
- Implement proper token rotation
- Log access but don't log sensitive data
- Follow PCI compliance guidelines

#### The User Experience

The Plaid Link flow is straightforward:
1. User clicks "Connect Bank"
2. Plaid Link modal opens
3. User selects their bank and logs in
4. We receive an access token
5. We can now fetch account data

#### Results

- 50% reduction in onboarding time
- Higher conversion rates
- Better user experience
- Reduced support tickets

#### Lessons Learned

1. Test thoroughly in sandbox before production
2. Handle all error cases gracefully
3. Provide clear user messaging
4. Monitor API usage and costs
5. Keep SDK updated

Plaid integration was a game-changer for our onboarding flow.



Integrating Plaid with TypeScript


Nam ut rutrum ex, venenatis sollicitudin urna. Aliquam erat volutpat. Integer eu ipsum sem Ut bibendum lacus vestibulum maximus suscipit, Quisque vitae nibh iaculis neque blandit euismod. Lorem ipsum dolor sit amet consectetur adipisicing elit. Nemo vel ad consectetur ut aperiam. Itaque eligendi natus aperiam? Excepturi repellendus consequatur quibusdam optio expedita praesentium est adipisci dolorem ut eius!

#### Covid-19 Situation

Nam ut rutrum ex, venenatis sollicitudin urna. Aliquam erat volutpat. Integer eu ipsum sem. Ut bibendum lacus vestibulum maximus suscipit. Quisque vitae nibh iaculis neque blandit euismod.

> Lorem ipsum dolor sit amet consectetur adipisicing elit. Nemo vel ad consectetur ut aperiam. Itaque eligendi natus aperiam? Excepturi repellendus consequatur quibusdam optio expedita praesentium est adipisci dolorem ut eius!

#### Work From Home

Lorem ipsum dolor sit amet consectetur adipisicing elit. Nemo vel ad consectetur ut aperiam. Itaque eligendi natus aperiam? Excepturi repellendus consequatur quibusdam optio expedita praesentium est adipisci dolorem ut eius! Lorem ipsum dolor sit amet consectetur adipisicing elit. Nemo vel ad consectetur ut aperiam. Itaque eligendi natus aperiam? Excepturi repellendus consequatur quibusdam optio expedita praesentium est adipisci dolorem ut eius!

Lorem ipsum dolor sit amet consectetur adipisicing elit. Nemo vel ad consectetur ut aperiam. Itaque eligendi natus aperiam? Excepturi repellendus consequatur quibusdam optio expedita praesentium est adipisci dolorem ut eius! Lorem ipsum dolor sit amet consectetur adipisicing elit. Nemo vel ad consectetur ut aperiam. Itaque eligendi natus aperiam? Excepturi repellendus consequatur quibusdam optio expedita praesentium est adipisci dolorem ut eius!



How to make toys from old Olarpaper

What you need to know about Photography


After years of experience in engineering leadership and fintech, I've learned that python async best practices requires careful attention to both technical excellence and human factors.

#### The Challenge

Python async best practices is something I've encountered throughout my career at companies like Mercury, Heard, Ness, and now Pangea. The key is understanding both the technical and human aspects.

#### Key Insights

1. **Technical Excellence**: Whether it's Python, TypeScript, or infrastructure, solid technical foundations matter.

2. **People First**: Engineering is ultimately about people-building systems that serve users and teams that thrive.

3. **Balance**: Finding the right balance between technical depth and practical application.

#### Lessons Learned

- Start with understanding the problem deeply
- Build iteratively and get feedback early
- Invest in both technical skills and soft skills
- Take care of your mental and physical health

> "The best engineering solutions come from understanding both the code and the people who use it."

#### Next Steps

Consider how python async best practices applies to your own work. What can you learn? What can you improve? How can you help others?



Remote team communication

Recruiting and scaling engineering teams

Building real-time analytics with RDRs

Python testing strategies for fintech

Building data pipelines for fintech with Python

Python async patterns for payment processing