The Context: A Complex Ecosystem
A growing real estate company needed to modernize its entire tech stack. This wasn't a single project — it was an ecosystem of interconnected platforms:
- Property Management CRM: For real estate agents
- Internal ERP: Operations, finance, human resources
- Public Websites: Property search portals
- Large-Scale Integrations: Web scraping, external APIs, real estate portals
The Challenge: Technical Leadership
My role was Tech Lead, responsible for:
- Full system architecture
- Leading a team of 6 developers
- Tech stack decisions
- Code reviews and mentoring
- Stakeholder coordination
Problems to Solve
1. Disconnected Systems
Each platform was an independent silo:
- Duplicated data across multiple databases
- Error-prone manual synchronization
- No "single source of truth"
2. Operational Inefficiency
- Agents uploading properties manually
- Reports in Excel sent via email
- Zero automation
3. Limited Scalability
- Legacy stack (PHP 5.6) that was hard to scale
- Not ready for growth
- High maintenance costs
The Solution: An Integrated Architecture
Decision: GraphQL as the Unification Layer
Instead of multiple disconnected REST APIs, we implemented GraphQL Federation:
┌──────────────────────────────────────────────────┐
│ GraphQL Gateway (Apollo) │
│ Unified API for all services │
└───────┬──────────────┬───────────────┬───────────┘
│ │ │
┌────▼────┐ ┌────▼────┐ ┌────▼────┐
│ CRM │ │ ERP │ │ Website │
│ Service │ │ Service │ │ Service │
└────┬────┘ └────┬────┘ └────┬────┘
│ │ │
┌────▼─────────────────────────────▼────┐
│ PostgreSQL (Single Database) │
└────────────────────────────────────────┘
Benefits of GraphQL:
- Flexible queries from the frontend
- A single request for data from multiple services
- End-to-end type safety
- Implicit versioning (no breaking changes)
Layered Architecture
// GraphQL resolver example
const resolvers = {
Query: {
property: async (_, { id }, context) => {
// Business logic in the resolver
const property = await propertyService.findById(id)
return property
}
},
Property: {
// Lazy loading of relationships
owner: async (property) => {
return userService.findById(property.ownerId)
},
images: async (property) => {
return imageService.findByPropertyId(property.id)
}
}
}
Ecosystem Components
1. Property Management CRM
Key features:
- Dashboard with real-time metrics
- Property management (full CRUD)
- Sales pipeline with kanban board
- Automatic lead assignment to agents
- Integrated visit calendar
- Reports and analytics
Stack:
- Frontend: React + TypeScript + Apollo Client
- Backend: GraphQL + Node.js
- Database: PostgreSQL with full-text search
2. Internal ERP
Implemented modules:
- Finance: Invoicing, accounts receivable/payable
- HR: Employee management, payroll
- Operations: Approval workflows
- Reports: Executive dashboards
CRM Integration:
# Query combining CRM and ERP data
query DashboardData {
# From CRM
activeProperties {
id
title
price
}
# From ERP
monthlyRevenue {
amount
currency
}
# Combined
salesPerformance {
agent {
name
commission
}
propertiesSold
totalValue
}
}
3. Public Websites
Features:
- Advanced property search
- Filters by location, price, and features
- 360° virtual property tours
- Contact forms with CRM integration
- SEO-optimized (SSR with Next.js)
Performance:
- Server-Side Rendering for SEO
- ISR (Incremental Static Regeneration)
- CDN for images
- Lazy loading of components
4. Web Scraping and Integrations
We automated property capture from multiple sources:
# Scraper with Scrapy
class PropertySpider(scrapy.Spider):
name = 'property_portal'
def parse(self, response):
for property in response.css('.property-item'):
yield {
'title': property.css('.title::text').get(),
'price': self.parse_price(property),
'location': property.css('.location::text').get(),
'url': property.css('a::attr(href)').get(),
}
async def save_to_crm(self, property_data):
# GraphQL mutation to save to CRM
await graphql_client.mutate(
mutation=CREATE_PROPERTY,
variables=property_data
)
Integrated sources:
- Public real estate portals
- Business partner APIs
- Real estate news RSS feeds
- Government APIs (public records)
Full Tech Stack
Frontend
- React 18 with TypeScript
- Apollo Client for GraphQL
- Material-UI for components
- React Query for caching
- Formik + Yup for forms
Backend
- Node.js + Express for complementary REST API
- Apollo Server for GraphQL
- Laravel (legacy ERP modules)
- Python + Scrapy for web scraping
Database & Storage
- PostgreSQL 14 with partitioning
- Redis for caching and sessions
- Elasticsearch for full-text search
- AWS S3 for images and documents
DevOps & Infrastructure
- Docker + Docker Compose for local dev
- Kubernetes (GKE) for production
- GitHub Actions for CI/CD
- Terraform for IaC
- Datadog for monitoring
Integrations
- Twilio for SMS and WhatsApp
- SendGrid for transactional emails
- Google Maps API for geocoding
- Cloudinary for image processing
Team Leadership
Team Structure
- 2 Senior Developers (fullstack)
- 3 Mid-level Developers
- 1 Junior Developer
- 1 DevOps Engineer (part-time)
Leadership Practices Implemented
1. Mandatory Code Reviews
Pull Request → 2 approvals → Automated Tests → Deploy
- Continuous team learning
- Consistent code quality
- Knowledge sharing
2. Pair Programming
- Juniors with Seniors: 2 hours/week
- Debugging complex problems
- Designing critical features
3. Internal Tech Talks
Biweekly 1-hour sessions:
- New technologies
- Best practices
- Incident post-mortems
4. Technical Documentation
- ADRs (Architecture Decision Records)
- Up-to-date architecture diagrams
- README with quick start for each repo
- Wiki with common troubleshooting
5. Weekly 1-on-1s
- Two-way feedback
- Career development
- Blocker resolution
Results
Business Metrics
- Users: From 500 to 2,000 in 18 months
- Efficiency: 70% reduction in property listing time
- Automation: 80% of properties captured automatically
- Revenue: 45% increase in generated commissions
Technical Metrics
- Performance: Average API response time < 100ms
- Scalability: System supports 10x current load
- Availability: 99.5% uptime
- Deploys: 3-4 releases per week with zero downtime
Team Impact
- Retention: 100% of the team stayed for 2+ years
- Growth: 2 juniors promoted to mid-level
- Satisfaction: Internal survey scored 4.5/5
Key Takeaways
1. GraphQL for Complex Ecosystems
GraphQL shines when you have multiple frontends consuming data from multiple backends. The flexibility and type safety are worth the learning curve.
2. Leadership Isn't Just About Code
As a Tech Lead, my best contributions weren't technical:
- Unblocking the team
- Facilitating communication with stakeholders
- Creating a learning environment
3. Automation = Fast ROI
Web scraping saved us hundreds of manual hours. Automation pays dividends.
4. Monorepo for Small Teams
We kept everything in a monorepo (with Lerna):
- Easier refactoring
- Synchronized versioning
- Code sharing across services
5. Documentation Is an Act of Love for Your Team
Time invested in documentation = a productivity multiplier for the team.
Need Technical Leadership?
If your company is in a growth phase and needs:
- Complex system architecture
- Development team leadership
- Technical mentoring
- Multi-platform integration
Let's talk about how I can help
Result: An ecosystem of integrated platforms serving 2,000+ users, with a modern GraphQL-based architecture and a motivated, productive engineering team.
