diff --git a/app/services/[slug]/ExpertisePageClient.tsx b/app/services/[slug]/ExpertisePageClient.tsx index 44c98f3..4999923 100644 --- a/app/services/[slug]/ExpertisePageClient.tsx +++ b/app/services/[slug]/ExpertisePageClient.tsx @@ -91,6 +91,22 @@ const bookingSubtext: Record = { "Talk directly with engineers, not sales. We'll assess fit and give honest next steps.", "thanos-long-term-storage": "Talk directly with engineers, not sales. We'll assess your monitoring stack and give honest next steps - even if that means you don't need Thanos yet.", + "typescript": + "Tell us about your TypeScript project. Whether it's a new build, migration from JavaScript, or improving type safety across your stack, we'll discuss architecture and give honest next steps.", + "postgresql": + "Tell us about your database challenges. Whether it's schema design, performance tuning, or migrating to PostgreSQL, we'll assess your data architecture and give honest next steps.", + "aws": + "Tell us about your cloud infrastructure needs. Whether it's a new deployment, migration to AWS, or cost optimization, we'll discuss architecture and give honest next steps.", + "golang": + "Tell us about your Go project. Whether it's microservices, CLI tooling, or a backend migration, we'll discuss architecture and give honest next steps.", + "mongodb": + "Tell us about your MongoDB project. Whether it's schema design, performance optimization, or migrating from another database, we'll assess your data architecture and give honest next steps.", + "java": + "Tell us about your Java project. Whether it's enterprise modernization, Spring Boot microservices, or a new build, we'll discuss architecture and give honest next steps.", + "kotlin": + "Tell us about your Kotlin project. Whether it's a new Android app, migrating from Java, or Kotlin Multiplatform, we'll discuss architecture and give honest next steps.", + "swift": + "Tell us about your iOS project. Whether it's a new app, migrating from Objective-C, or expanding to watchOS/tvOS, we'll discuss architecture and give honest next steps.", }; // Technology logo paths for the "What you get" section @@ -103,6 +119,14 @@ const technologyLogos: Record = { dotnet: "/technologies/dotnet-logo.svg", flutter: "/technologies/flutter-logo.svg", "react-native": "/technologies/react-logo.svg", + typescript: "/technologies/typescript-logo.svg", + postgresql: "/technologies/postgresql-logo.svg", + aws: "/technologies/aws-logo.svg", + golang: "/technologies/golang-logo.svg", + mongodb: "/technologies/mongodb-logo.svg", + java: "/technologies/java-logo.svg", + kotlin: "/technologies/kotlin-logo.svg", + swift: "/technologies/swift-logo.svg", }; // "What you get" content per technology - used in the hire section @@ -155,6 +179,73 @@ const whatYouGetContent: Record )} - {["react", "nextjs", "nodejs", "python", "angular", "flutter", "react-native"].includes(expertise.slug) && ( + {["react", "nextjs", "nodejs", "python", "angular", "flutter", "react-native", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) && ( )} -
+
@@ -272,17 +363,17 @@ export default function ExpertisePageClient({ {expertise.slug === "dotnet" && } {/* Non-dotnet tech pages: Industries section */} - {["react", "nextjs", "nodejs", "python", "angular", "flutter", "react-native"].includes(expertise.slug) && ( + {["react", "nextjs", "nodejs", "python", "angular", "flutter", "react-native", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) && ( )} {/* Tech slugs: Decision tables (dynamically imported) */} - {["nodejs", "react", "python", "angular", "flutter", "react-native"].includes(expertise.slug) && ( + {["nodejs", "react", "python", "angular", "flutter", "react-native", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) && ( )} {/* Tech slugs: Framework comparisons (dynamically imported) */} - {["react", "python", "flutter", "react-native", "nodejs", "nextjs", "angular", "dotnet"].includes(expertise.slug) && ( + {["react", "python", "flutter", "react-native", "nodejs", "nextjs", "angular", "dotnet", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) && ( )} @@ -296,10 +387,10 @@ export default function ExpertisePageClient({ )} {pageData.process && ( -
+
@@ -340,7 +431,7 @@ export default function ExpertisePageClient({ { category: "CI/CD & Monitoring", items: ["GitHub Actions", "Vercel Analytics", "Sentry", "DataDog"] }, ]} /> - ) : ["nodejs", "react", "python", "angular", "react-native", "flutter", "prometheus-monitoring", "thanos-long-term-storage", "istio-consulting"].includes(expertise.slug) ? ( + ) : ["nodejs", "react", "python", "angular", "react-native", "flutter", "prometheus-monitoring", "thanos-long-term-storage", "istio-consulting", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) ? ( ) : ( + {["dotnet", "nextjs", "nodejs", "react", "python", "angular", "flutter", "react-native", "prometheus-monitoring", "istio-consulting", "thanos-long-term-storage", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) && ( +

- {expertise.slug === "flutter" || expertise.slug === "react-native" + {expertise.slug === "flutter" || expertise.slug === "react-native" || expertise.slug === "kotlin" || expertise.slug === "swift" ? <>Let's Talk About Your App : expertise.slug === "prometheus-monitoring" ? <>Not Sure If Prometheus Is Right for Your Stack? @@ -408,7 +499,7 @@ export default function ExpertisePageClient({ ? <>Prometheus Metrics Growing Faster Than Your Retention Budget? : expertise.slug === "istio-consulting" ? <>Not Sure If You Need a Service Mesh? - : <>Discuss Your {expertise.slug === "nextjs" ? "Next.js" : expertise.slug === "nodejs" ? "Node.js" : expertise.slug === "react" ? "React" : expertise.slug === "python" ? "Python" : expertise.slug === "angular" ? "Angular" : ".NET"} Project + : <>Discuss Your {expertise.slug === "nextjs" ? "Next.js" : expertise.slug === "nodejs" ? "Node.js" : expertise.slug === "react" ? "React" : expertise.slug === "python" ? "Python" : expertise.slug === "angular" ? "Angular" : expertise.slug === "typescript" ? "TypeScript" : expertise.slug === "postgresql" ? "PostgreSQL" : expertise.slug === "aws" ? "AWS" : expertise.slug === "golang" ? "Go" : expertise.slug === "mongodb" ? "MongoDB" : expertise.slug === "java" ? "Java" : expertise.slug === "kotlin" ? "Kotlin" : expertise.slug === "swift" ? "Swift" : ".NET"} Project }

@@ -432,6 +523,22 @@ export default function ExpertisePageClient({ ? "We'll audit your current setup and tell you whether Thanos is the right move - or if something else makes more sense." : expertise.slug === "istio-consulting" ? "We'll give you an honest assessment. Sometimes the answer is \"not yet\" or \"use something simpler.\" We'd rather tell you that upfront." + : expertise.slug === "typescript" + ? "Whether it\u2019s a new build, JavaScript migration, or improving type safety, we\u2019re happy to talk through your situation." + : expertise.slug === "postgresql" + ? "Whether it\u2019s schema design, performance tuning, or migrating databases, we\u2019re happy to talk through your situation." + : expertise.slug === "aws" + ? "Whether it\u2019s a new deployment, cloud migration, or cost optimization, we\u2019re happy to talk through your situation." + : expertise.slug === "golang" + ? "Whether it\u2019s microservices, CLI tools, or a backend migration to Go, we\u2019re happy to talk through your situation." + : expertise.slug === "mongodb" + ? "Whether it\u2019s schema design, performance optimization, or migrating databases, we\u2019re happy to talk through your situation." + : expertise.slug === "java" + ? "Whether it\u2019s enterprise modernization, Spring Boot microservices, or a new build, we\u2019re happy to talk through your situation." + : expertise.slug === "kotlin" + ? "Whether it\u2019s a new Android app, Java migration, or Kotlin Multiplatform, we\u2019re happy to talk through your situation." + : expertise.slug === "swift" + ? "Whether it\u2019s a new iOS app, Objective-C migration, or expanding to watchOS/tvOS, we\u2019re happy to talk through your situation." : "Whether modernizing legacy systems or building new, we\u2019re happy to talk through your situation."}

+
{/* "What you get" block with technology logo - before EngagementModels */} {whatYouGetContent[expertise.slug] && (
@@ -544,7 +651,7 @@ export default function ExpertisePageClient({ /> {/* Node.js / React / Python / Angular / Flutter: Pricing line + CTA after EngagementModels */} - {["nodejs", "react", "python", "angular", "flutter", "react-native"].includes(expertise.slug) && ( + {["nodejs", "react", "python", "angular", "flutter", "react-native", "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift"].includes(expertise.slug) && (
{pageData.faqs.length > 0 && ( -
+
diff --git a/app/services/[slug]/ExpertisePageHero.tsx b/app/services/[slug]/ExpertisePageHero.tsx index e0bee0c..f72495f 100644 --- a/app/services/[slug]/ExpertisePageHero.tsx +++ b/app/services/[slug]/ExpertisePageHero.tsx @@ -15,12 +15,21 @@ const heroCTAMap: Record = { "prometheus-monitoring": { text: "Talk to a Prometheus Engineer", href: "#book-call" }, "istio-consulting": { text: "Talk to an Istio Engineer", href: "#book-call" }, "thanos-long-term-storage": { text: "Talk to a Thanos Engineer", href: "#book-call" }, + "typescript": { text: "Talk to a TypeScript Engineer", href: "#book-call" }, + "postgresql": { text: "Talk to a PostgreSQL Engineer", href: "#book-call" }, + "aws": { text: "Talk to an AWS Engineer", href: "#book-call" }, + "golang": { text: "Talk to a Go Engineer", href: "#book-call" }, + "mongodb": { text: "Talk to a MongoDB Engineer", href: "#book-call" }, + "java": { text: "Talk to a Java Engineer", href: "#book-call" }, + "kotlin": { text: "Talk to a Kotlin Engineer", href: "#book-call" }, + "swift": { text: "Talk to a Swift Engineer", href: "#book-call" }, }; const noSecondaryCTASlugs = [ "ai-engineering", "ai-agents", "dotnet", "nextjs", "nodejs", "react", "python", "angular", "flutter", "react-native", "prometheus-monitoring", "istio-consulting", "thanos-long-term-storage", + "typescript", "postgresql", "aws", "golang", "mongodb", "java", "kotlin", "swift", ]; const checkSvg = ( @@ -146,6 +155,62 @@ const heroChildrenMap: Record = { { href: "#fit", text: "Is Thanos right for you?" }, ], }, + "typescript": { + badges: ["Free architecture review", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#hire", text: "Need developers on your team?" }, + ], + }, + "postgresql": { + badges: ["Free database assessment", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#fit", text: "Is PostgreSQL right for you?" }, + ], + }, + "aws": { + badges: ["Free architecture review", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#fit", text: "Is AWS right for you?" }, + ], + }, + "golang": { + badges: ["Free architecture review", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#fit", text: "Is Go right for you?" }, + ], + }, + "mongodb": { + badges: ["Free database assessment", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#fit", text: "Is MongoDB right for you?" }, + ], + }, + "java": { + badges: ["Free architecture review", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#hire", text: "Need developers on your team?" }, + ], + }, + "kotlin": { + badges: ["No obligation", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#hire", text: "Need developers on your team?" }, + ], + }, + "swift": { + badges: ["No obligation", "30-minute call", "Talk to engineers, not sales"], + links: [ + { href: "#services", text: "See our services" }, + { href: "#hire", text: "Need developers on your team?" }, + ], + }, }; export function ExpertisePageHero({ expertise }: { expertise: ExpertisePageForListing }) { diff --git a/app/services/[slug]/slug-sections/CustomStackTable.tsx b/app/services/[slug]/slug-sections/CustomStackTable.tsx index 7c9bd84..66c05ca 100644 --- a/app/services/[slug]/slug-sections/CustomStackTable.tsx +++ b/app/services/[slug]/slug-sections/CustomStackTable.tsx @@ -574,6 +574,513 @@ const dataMap: Record = { }, ], }, + typescript: { + type: "three-column", + title: "Our", + highlight: "TypeScript", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with and why.", + whyHeader: "Why", + rows: [ + { + layer: "Language", + tools: "TypeScript 5.x strict", + why: "Strict mode catches entire categories of bugs at compile time. Non-negotiable on our projects.", + }, + { + layer: "Framework", + tools: "React, Next.js, NestJS, Angular", + why: "React/Next.js for frontends, NestJS for backend structure, Angular for enterprise apps", + }, + { + layer: "Build", + tools: "Vite, Turbopack, SWC", + why: "Sub-second HMR with Vite, Turbopack for Next.js, SWC for fast transpilation", + }, + { + layer: "ORM / Query", + tools: "Prisma, Drizzle, TypeORM", + why: "Prisma for type-safe queries and migrations, Drizzle for edge runtimes, TypeORM for legacy codebases", + }, + { + layer: "Database", + tools: "PostgreSQL, MongoDB, Redis", + why: "Postgres for relational data, MongoDB for document workloads, Redis for caching and queues", + }, + { + layer: "API Style", + tools: "REST, GraphQL, tRPC", + why: "REST for public APIs, GraphQL for frontend flexibility, tRPC for end-to-end type safety without codegen", + }, + { + layer: "State Management", + tools: "Zustand, Redux Toolkit, TanStack Query", + why: "Zustand for simple state, Redux Toolkit for complex flows, TanStack Query for server state", + }, + { + layer: "Forms", + tools: "React Hook Form, Zod", + why: "Performant forms with schema-based validation. Zod schemas shared between client and server.", + }, + { + layer: "Testing", + tools: "Vitest, Playwright, Jest", + why: "Vitest for unit tests, Playwright for E2E, Jest for legacy projects and Node.js services", + }, + { + layer: "Hosting", + tools: "Vercel, AWS, Cloudflare", + why: "Vercel for Next.js, AWS for containers and serverless, Cloudflare for edge-first apps", + }, + { + layer: "CI/CD", + tools: "GitHub Actions, Docker", + why: "Automated type checking, tests, and deployments on every merge", + }, + { + layer: "Monitoring", + tools: "Sentry, Datadog", + why: "Error tracking with full source map support, APM for performance bottlenecks", + }, + ], + bottomNote: + "TypeScript is not optional on our projects. Strict mode, no any escapes, shared Zod schemas between frontend and backend. The type system is the first line of defense, not an afterthought.", + }, + postgresql: { + type: "three-column", + title: "Our", + highlight: "PostgreSQL", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with and why.", + whyHeader: "Why", + rows: [ + { + layer: "Database", + tools: "PostgreSQL 17", + why: "Latest stable with incremental backup, improved JSON handling, and better query performance", + }, + { + layer: "Extensions", + tools: "PostGIS, pg_vector, TimescaleDB, Citus", + why: "PostGIS for spatial data, pg_vector for AI embeddings, TimescaleDB for time series, Citus for horizontal scaling", + }, + { + layer: "ORM / Query", + tools: "Prisma, SQLAlchemy, TypeORM, Drizzle", + why: "Prisma for TypeScript, SQLAlchemy for Python, TypeORM/Drizzle depending on runtime constraints", + }, + { + layer: "Migration", + tools: "Flyway, Alembic, Prisma Migrate", + why: "Flyway for Java/enterprise, Alembic for Python stacks, Prisma Migrate for TypeScript", + }, + { + layer: "Monitoring", + tools: "pganalyze, pg_stat_statements, Grafana", + why: "pganalyze for query optimization insights, pg_stat_statements for bottleneck identification, Grafana for dashboards", + }, + { + layer: "Replication", + tools: "Streaming replication, Patroni, pgBouncer", + why: "Streaming replication for HA, Patroni for automated failover, pgBouncer for connection pooling", + }, + { + layer: "Backup", + tools: "pg_dump, Barman, WAL-G", + why: "pg_dump for logical backups, Barman for physical backup management, WAL-G for WAL archiving to cloud storage", + }, + { + layer: "Cloud Managed", + tools: "AWS RDS, Aurora, Cloud SQL, Azure Database", + why: "RDS for straightforward hosting, Aurora for high throughput, Cloud SQL and Azure for multi-cloud", + }, + { + layer: "Infrastructure", + tools: "Docker, Kubernetes, Terraform", + why: "Containerized deployments with infrastructure as code for reproducible environments", + }, + { + layer: "CI/CD", + tools: "GitHub Actions, automated migration testing", + why: "Every migration runs against a test database before touching production", + }, + ], + bottomNote: + "PostgreSQL handles relational data, vector search, geospatial queries, and time series in a single engine. We use extensions instead of adding databases. Fewer moving parts means fewer things to break at 3 AM.", + }, + aws: { + type: "three-column", + title: "Our", + highlight: "AWS", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with and why.", + whyHeader: "Why", + rows: [ + { + layer: "Compute", + tools: "EC2, ECS, Lambda, Fargate", + why: "EC2 for full control, ECS/Fargate for containers without cluster management, Lambda for event-driven workloads", + }, + { + layer: "Storage", + tools: "S3, EBS, EFS", + why: "S3 for object storage, EBS for block storage on EC2, EFS for shared file systems across containers", + }, + { + layer: "Database", + tools: "RDS, Aurora, DynamoDB, ElastiCache", + why: "RDS for managed Postgres/MySQL, Aurora for high throughput, DynamoDB for key-value at scale, ElastiCache for Redis", + }, + { + layer: "Networking", + tools: "VPC, ALB, CloudFront, Route 53", + why: "VPC for network isolation, ALB for load balancing, CloudFront for global CDN, Route 53 for DNS", + }, + { + layer: "Security", + tools: "IAM, KMS, WAF, GuardDuty", + why: "Least-privilege IAM policies, KMS for encryption, WAF for web protection, GuardDuty for threat detection", + }, + { + layer: "Containers", + tools: "ECS, EKS, ECR", + why: "ECS for simpler orchestration, EKS when you need full Kubernetes, ECR for private container registries", + }, + { + layer: "Serverless", + tools: "Lambda, API Gateway, Step Functions, EventBridge", + why: "Lambda for compute, API Gateway for endpoints, Step Functions for workflows, EventBridge for event routing", + }, + { + layer: "Monitoring", + tools: "CloudWatch, X-Ray, CloudTrail", + why: "CloudWatch for metrics and alarms, X-Ray for distributed tracing, CloudTrail for audit logs", + }, + { + layer: "IaC", + tools: "Terraform, CDK, CloudFormation", + why: "Terraform for multi-cloud, CDK for TypeScript-native IaC, CloudFormation for AWS-only stacks", + }, + { + layer: "CI/CD", + tools: "CodePipeline, GitHub Actions", + why: "CodePipeline for AWS-native workflows, GitHub Actions for cross-platform builds and deployments", + }, + { + layer: "AI/ML", + tools: "SageMaker, Bedrock, Comprehend", + why: "SageMaker for custom model training, Bedrock for managed foundation models, Comprehend for NLP", + }, + ], + bottomNote: + "We default to the simplest AWS service that solves the problem. Fargate over EKS unless you need Kubernetes. Lambda over containers for event-driven workloads. The goal is less infrastructure to manage, not more services on the bill.", + }, + golang: { + type: "three-column", + title: "Our", + highlight: "Go", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with and why.", + whyHeader: "Why", + rows: [ + { + layer: "Language", + tools: "Go 1.23+", + why: "Range-over-func iterators, enhanced servemux routing, and continued performance improvements", + }, + { + layer: "Web Framework", + tools: "Gin, Echo, Chi, Fiber", + why: "Gin for established APIs, Echo for middleware-heavy services, Chi for stdlib compatibility, Fiber for raw throughput", + }, + { + layer: "gRPC", + tools: "gRPC-Go, Protocol Buffers", + why: "Low-latency service-to-service communication with code-generated type-safe clients", + }, + { + layer: "ORM / Query", + tools: "GORM, sqlc, pgx", + why: "GORM for rapid development, sqlc for compile-time SQL validation, pgx for raw Postgres performance", + }, + { + layer: "Database", + tools: "PostgreSQL, Redis, MongoDB", + why: "Postgres for relational data, Redis for caching and pub/sub, MongoDB for document workloads", + }, + { + layer: "Message Queue", + tools: "Kafka, NATS, RabbitMQ", + why: "Kafka for high-throughput event streaming, NATS for lightweight messaging, RabbitMQ for reliable task queues", + }, + { + layer: "Testing", + tools: "Go testing, testify, gomock", + why: "Standard library testing for most cases, testify for assertions, gomock for interface mocking", + }, + { + layer: "API Style", + tools: "REST, gRPC, GraphQL via gqlgen", + why: "REST for public APIs, gRPC for internal services, gqlgen for type-safe GraphQL from Go structs", + }, + { + layer: "Hosting", + tools: "AWS ECS/Lambda, GCP Cloud Run, Kubernetes", + why: "ECS for containers, Lambda for event-driven, Cloud Run for fast autoscaling, Kubernetes for complex orchestration", + }, + { + layer: "CI/CD", + tools: "GitHub Actions, Docker, GoReleaser", + why: "GitHub Actions for pipeline automation, Docker for consistent builds, GoReleaser for binary distribution", + }, + { + layer: "Monitoring", + tools: "Prometheus, Grafana, OpenTelemetry", + why: "Prometheus for metrics collection, Grafana for dashboards, OpenTelemetry for distributed tracing", + }, + ], + bottomNote: + "Go compiles to a single static binary with no runtime dependencies. That means smaller containers, faster cold starts, and fewer things to debug in production. We reach for Go when performance and operational simplicity matter more than ecosystem breadth.", + }, + mongodb: { + type: "three-column", + title: "Our", + highlight: "MongoDB", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with and why.", + whyHeader: "Why", + rows: [ + { + layer: "Database", + tools: "MongoDB 8.x", + why: "Queryable encryption, improved aggregation performance, and native vector search support", + }, + { + layer: "Drivers", + tools: "MongoDB Node.js Driver, PyMongo, Mongoose", + why: "Native drivers for each language with full feature support and connection pooling", + }, + { + layer: "ODM", + tools: "Mongoose, Prisma, Motor", + why: "Mongoose for schema validation in Node.js, Prisma for type-safe access, Motor for async Python", + }, + { + layer: "Atlas", + tools: "MongoDB Atlas, Atlas Search, Atlas Data Federation", + why: "Atlas for managed hosting, Atlas Search for full-text without Elasticsearch, Data Federation for cross-source queries", + }, + { + layer: "Aggregation", + tools: "Aggregation Pipeline, Atlas Charts", + why: "Pipeline for complex data transformations in-database, Charts for embedded analytics without BI tools", + }, + { + layer: "Change Streams", + tools: "Real-time data sync, event-driven pipelines", + why: "Push-based change notifications for real-time features without polling the database", + }, + { + layer: "Security", + tools: "Encryption at rest, field-level encryption, RBAC", + why: "Encryption at rest for compliance, field-level encryption for sensitive data, RBAC for least-privilege access", + }, + { + layer: "Monitoring", + tools: "MongoDB Atlas monitoring, Grafana, Datadog", + why: "Atlas monitoring for database-specific metrics, Grafana/Datadog for unified infrastructure dashboards", + }, + { + layer: "Backup", + tools: "Atlas backup, mongodump, Ops Manager", + why: "Atlas continuous backup for point-in-time recovery, mongodump for logical backups, Ops Manager for on-prem", + }, + { + layer: "Infrastructure", + tools: "Docker, Kubernetes, Terraform", + why: "Containerized replica sets for development parity, Terraform for provisioning Atlas clusters as code", + }, + ], + bottomNote: + "MongoDB is the right choice when your data model is document-oriented and schema flexibility matters. We use Atlas for managed infrastructure and lean on aggregation pipelines to keep processing in the database instead of the application layer.", + }, + java: { + type: "three-column", + title: "Our", + highlight: "Java", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with and why.", + whyHeader: "Why", + rows: [ + { + layer: "Language", + tools: "Java 21+ LTS", + why: "Virtual threads, pattern matching, record types. Modern Java is not the Java you remember.", + }, + { + layer: "Framework", + tools: "Spring Boot 3.x, Quarkus, Micronaut", + why: "Spring Boot for enterprise ecosystems, Quarkus for fast startup and native images, Micronaut for low memory footprint", + }, + { + layer: "ORM", + tools: "Spring Data JPA, Hibernate 6", + why: "Spring Data JPA for repository abstraction, Hibernate 6 for full ORM control and advanced mappings", + }, + { + layer: "Database", + tools: "PostgreSQL, MongoDB, Redis", + why: "Postgres for relational data, MongoDB for document workloads, Redis for caching and session storage", + }, + { + layer: "Message Queue", + tools: "Kafka, RabbitMQ, AWS SQS", + why: "Kafka for event streaming at scale, RabbitMQ for reliable task queues, SQS for serverless integrations", + }, + { + layer: "API Style", + tools: "REST, GraphQL, gRPC", + why: "REST for public APIs, GraphQL for flexible frontend queries, gRPC for low-latency internal communication", + }, + { + layer: "Security", + tools: "Spring Security, OAuth2, JWT", + why: "Spring Security for comprehensive auth, OAuth2 for third-party login, JWT for stateless token-based auth", + }, + { + layer: "Testing", + tools: "JUnit 5, Mockito, Testcontainers", + why: "JUnit 5 for unit tests, Mockito for mocking, Testcontainers for integration tests against real databases", + }, + { + layer: "Build", + tools: "Gradle, Maven", + why: "Gradle for flexible builds and better performance, Maven when convention-over-configuration matters", + }, + { + layer: "Hosting", + tools: "AWS ECS, Kubernetes, GCP", + why: "ECS for managed containers, Kubernetes for complex orchestration, GCP for teams already in that ecosystem", + }, + { + layer: "CI/CD", + tools: "GitHub Actions, Jenkins, Docker", + why: "GitHub Actions for modern pipelines, Jenkins for enterprise workflows, Docker for consistent builds", + }, + { + layer: "Monitoring", + tools: "Micrometer, Prometheus, Grafana, ELK", + why: "Micrometer for metrics instrumentation, Prometheus/Grafana for dashboards, ELK for centralized logging", + }, + ], + bottomNote: + "Java 21 with virtual threads changes the concurrency story entirely. Spring Boot 3.x on GraalVM native images delivers startup times that compete with Go. We build Java services that are fast to develop and fast to run.", + }, + kotlin: { + type: "two-column", + title: "Our", + highlight: "Kotlin", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with.", + rows: [ + { layer: "Language", tools: "Kotlin 2.x" }, + { layer: "Android UI", tools: "Jetpack Compose, Material 3" }, + { + layer: "Architecture", + tools: "MVVM, MVI, Clean Architecture", + }, + { layer: "Dependency Injection", tools: "Hilt, Koin" }, + { + layer: "Networking", + tools: "Retrofit, Ktor Client, OkHttp", + }, + { + layer: "Local Storage", + tools: "Room, DataStore, SQLDelight", + }, + { + layer: "Navigation", + tools: "Jetpack Navigation, Compose Navigation", + }, + { + layer: "Testing", + tools: "JUnit, Espresso, Robolectric, Compose Test", + }, + { layer: "Server-Side", tools: "Ktor, Spring Boot" }, + { + layer: "Multiplatform", + tools: "Kotlin Multiplatform, Compose Multiplatform", + }, + { + layer: "CI/CD", + tools: "GitHub Actions, Fastlane, Gradle", + }, + { + layer: "Distribution", + tools: "Play Store, Firebase App Distribution", + }, + ], + bottomNote: + "Jetpack Compose is the default for new Android projects. We use Kotlin Multiplatform when sharing business logic with iOS makes sense, not as a blanket rule. Architecture choices scale with the project - MVVM for straightforward apps, MVI when state management complexity demands it.", + }, + swift: { + type: "two-column", + title: "Our", + highlight: "Swift", + afterHighlight: "Stack", + subtitle: + "Every tool earns its place. Here\u2019s what we ship with.", + rows: [ + { layer: "Language", tools: "Swift 6, strict concurrency" }, + { layer: "UI Framework", tools: "SwiftUI, UIKit" }, + { + layer: "Architecture", + tools: "MVVM, TCA, Clean Architecture", + }, + { layer: "Package Manager", tools: "Swift Package Manager" }, + { + layer: "Networking", + tools: "URLSession, Alamofire, async/await", + }, + { + layer: "Local Storage", + tools: "Core Data, SwiftData, UserDefaults", + }, + { + layer: "Testing", + tools: "XCTest, Swift Testing, snapshot tests", + }, + { + layer: "watchOS", + tools: "WatchKit, HealthKit, ClockKit", + }, + { + layer: "CI/CD", + tools: "Xcode Cloud, Fastlane, GitHub Actions", + }, + { + layer: "Distribution", + tools: "App Store, TestFlight, Enterprise", + }, + { + layer: "Monitoring", + tools: "Sentry, Firebase Crashlytics", + }, + { + layer: "Accessibility", + tools: "VoiceOver, Dynamic Type, SwiftUI accessibility modifiers", + }, + ], + bottomNote: + "SwiftUI is the default for new iOS projects. We drop into UIKit when SwiftUI hits its limits - complex collection views, custom transitions, or legacy codebases. Swift 6 strict concurrency catches data races at compile time, which matters more than most teams realize.", + }, }; function ThreeColumnTable({ data }: { data: ThreeColumnData }) { diff --git a/app/services/[slug]/slug-sections/FrameworkComparison.tsx b/app/services/[slug]/slug-sections/FrameworkComparison.tsx index 9efd820..53e4ad8 100644 --- a/app/services/[slug]/slug-sections/FrameworkComparison.tsx +++ b/app/services/[slug]/slug-sections/FrameworkComparison.tsx @@ -402,6 +402,414 @@ const comparisonDataMap: Record = { ), }, + typescript: { + sectionId: "typescript-vs-alternatives", + title: "TypeScript vs JavaScript:", + highlight: "When You Need What", + subtitle: "We use both. Here's how we decide.", + gridCols: "md:grid-cols-2", + frameworks: [ + { + name: "TypeScript", + bestFor: + "Large codebases, team projects, long-lived applications, shared API contracts", + why: "Static types catch bugs at compile time, serve as living documentation, and make refactoring safe. IDE support (autocompletion, inline errors, go-to-definition) is dramatically better with types. Adoption is near-universal for serious JavaScript projects.", + useWhen: + "Your project has more than one developer, will be maintained for over a year, or shares types between frontend and backend. The upfront cost of types pays for itself within weeks on any non-trivial project.", + }, + { + name: "JavaScript (plain)", + bestFor: + "Quick prototypes, scripts, small utilities, solo projects with short lifespans", + why: "Zero configuration, instant feedback, no compile step. When you need to ship a script or validate an idea in hours, TypeScript's setup overhead isn't worth it. Every TypeScript developer still writes plain JavaScript when the situation calls for it.", + useWhen: + "You're writing a one-off script, prototyping an idea to validate before investing in proper architecture, or building a small utility that won't grow beyond a single file.", + }, + ], + bottomNote: ( + <> + The line between TypeScript and JavaScript is thinner than the debate + suggests. TypeScript compiles to JavaScript. The question isn't + which language, it's how much type safety your project needs right + now. We default to TypeScript for production code and use plain + JavaScript for scripts and prototypes. For the backend, we pair + TypeScript with{" "} + + Node.js + {" "} + or{" "} + + Next.js + + . + + ), + }, + postgresql: { + sectionId: "postgresql-vs-alternatives", + title: "PostgreSQL vs MongoDB vs Redis:", + highlight: "When You Need What", + subtitle: "We use all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "PostgreSQL", + bestFor: + "Complex relational data, ACID transactions, regulatory compliance, mixed workloads (SQL + JSON + full-text search)", + why: "The most capable open-source relational database. JOINs, foreign keys, window functions, CTEs, JSONB, and PostGIS in one engine. When your data has relationships that need enforcement, PostgreSQL handles it at the database level.", + useWhen: + "Your data is relational, you need multi-table transactions, or compliance requires strong consistency guarantees. Also when you need JSON flexibility alongside relational structure (JSONB columns with GIN indexes).", + }, + { + name: "MongoDB", + bestFor: + "Document-shaped data, rapidly evolving schemas, content management, real-time analytics, horizontal scaling", + why: "Flexible schema means no migrations for every product change. The aggregation pipeline handles complex analytics. Native sharding scales horizontally across regions. Atlas simplifies operations with managed infrastructure.", + useWhen: + "Your data is naturally document-shaped (catalogs, user profiles, CMS content), schema changes are frequent, or you need to scale writes horizontally across regions.", + }, + { + name: "Redis", + bestFor: + "Caching, session storage, real-time leaderboards, rate limiting, pub/sub messaging", + why: "In-memory data store operating at microsecond latency. Data structures (sorted sets, streams, HyperLogLog) solve common problems without application logic. Redis Stack adds JSON, search, and time-series on top.", + useWhen: + "You need sub-millisecond reads, are caching database queries or API responses, need real-time counters or leaderboards, or want pub/sub messaging between services.", + }, + ], + bottomNote: ( + <> + Most production systems use more than one.{" "} + + PostgreSQL + {" "} + for the core transactional data,{" "} + + MongoDB + {" "} + for flexible document storage, and Redis for caching and real-time + features. We design data architectures that use each database for what + it does best rather than forcing one to do everything. + + ), + }, + aws: { + sectionId: "aws-vs-alternatives", + title: "AWS vs Azure vs GCP:", + highlight: "When You Need What", + subtitle: "We deploy on all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "AWS", + bestFor: + "Broadest service catalog, startup-to-enterprise scaling, global deployments, regulated industries", + why: "200+ services covering every workload. Largest global infrastructure (33 regions). Most compliance certifications. The default choice when you need breadth, maturity, and the deepest talent pool of cloud engineers.", + useWhen: + "You need a specific managed service that only AWS offers, your team already has AWS expertise, you're deploying globally and need the most regions, or compliance requires FedRAMP/GovCloud.", + }, + { + name: "Azure", + bestFor: + "Microsoft ecosystem shops (.NET, Active Directory, SQL Server), enterprise hybrid cloud, AI services (OpenAI partnership)", + why: "Native Active Directory integration, first-class .NET support, and the strongest hybrid cloud story with Azure Arc. Microsoft's OpenAI partnership means Azure gets GPT models first. Enterprise agreements bundle discounts with existing Microsoft licensing.", + useWhen: + "Your organization runs on Microsoft (AD, Office 365, .NET), you need hybrid cloud connecting on-premise to cloud, or you want priority access to OpenAI models through Azure OpenAI Service.", + }, + { + name: "Google Cloud (GCP)", + bestFor: + "ML/AI workloads (TPUs, Vertex AI), data analytics (BigQuery), Kubernetes-native teams, cost-optimized compute", + why: "Google built Kubernetes and runs it best on GKE. BigQuery is the fastest serverless data warehouse. TPU pods provide ML training performance that AWS and Azure can't match. Sustained-use discounts apply automatically.", + useWhen: + "ML training is a core workload and you need TPU infrastructure, BigQuery is your analytics backbone, you want the best managed Kubernetes experience, or your team values Google's developer-friendly tooling.", + }, + ], + bottomNote: ( + <> + Multi-cloud is common but rarely for redundancy. Most organizations + pick a primary cloud based on team expertise and workload, with + selective use of another cloud's strengths (GCP for BigQuery, AWS + for Lambda, Azure for AD integration). We help teams avoid unnecessary + complexity while leveraging each cloud's genuine advantages. + + ), + }, + golang: { + sectionId: "golang-vs-alternatives", + title: "Go vs Node.js vs Rust:", + highlight: "When You Need What", + subtitle: "We build with all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "Go", + bestFor: + "High-throughput APIs, microservices, infrastructure tooling, CLI tools, DevOps automation", + why: "Compiled to a single static binary. Goroutines handle massive concurrency without callback complexity. Sub-millisecond cold starts and tiny memory footprint make it ideal for containerized and serverless deployments. The cloud-native ecosystem (Kubernetes, Docker, Terraform) is built in Go.", + useWhen: + "You need high throughput with low latency, operational simplicity matters (single binary, no runtime), or you're building infrastructure-level services where startup time and memory footprint are critical.", + }, + { + name: "Node.js (TypeScript)", + bestFor: + "Full-stack JavaScript teams, real-time apps (WebSocket, SSE), API gateways, BFF layers", + why: "Same language on frontend and backend eliminates context switching. The npm ecosystem has a package for almost everything. Event-driven I/O handles concurrent connections efficiently for I/O-bound workloads.", + useWhen: + "Your team is JavaScript-native and you want full-stack velocity, you're building real-time features, or you need a lightweight API layer between frontend and downstream services.", + }, + { + name: "Rust", + bestFor: + "Systems programming, WebAssembly, performance-critical services, embedded systems, safety-critical applications", + why: "Zero-cost abstractions and no garbage collector mean predictable, maximum performance. Memory safety without a runtime. When Go is fast enough for most workloads, Rust is for when 'most' isn't enough.", + useWhen: + "You need bare-metal performance without garbage collection pauses, are building WASM modules for the browser, or require memory safety guarantees for safety-critical systems. Rust's learning curve is steep, so reserve it for workloads that justify the investment.", + }, + ], + bottomNote: ( + <> + Go is our default for new backend services where performance and + simplicity matter.{" "} + + Node.js + {" "} + wins when the team is JavaScript-native and full-stack velocity is the + priority. Rust is reserved for performance-critical paths where Go + isn't fast enough (which is rare). We frequently run Go and + Node.js services side by side in the same system, each handling the + workload it's best suited for. + + ), + }, + mongodb: { + sectionId: "mongodb-vs-alternatives", + title: "MongoDB vs PostgreSQL vs DynamoDB:", + highlight: "When You Need What", + subtitle: "We use all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "MongoDB", + bestFor: + "Document-shaped data, flexible schemas, content platforms, real-time analytics, horizontal scaling", + why: "Schema flexibility lets you iterate without migrations. The aggregation pipeline handles complex analytics natively. Atlas provides managed multi-region deployments with built-in monitoring. Native sharding scales writes horizontally.", + useWhen: + "Your data model is document-oriented (varying attributes, nested objects), you need to iterate on schema quickly during product development, or you need horizontal write scaling across regions.", + }, + { + name: "PostgreSQL", + bestFor: + "Relational data, complex JOINs, ACID transactions, regulatory compliance, mixed SQL + JSON workloads", + why: "The most capable open-source relational database. When your data has strict relationships, foreign key constraints, and multi-table transactions, PostgreSQL enforces correctness at the database level. JSONB gives you document flexibility within a relational model.", + useWhen: + "Your data is fundamentally relational, you need multi-table ACID transactions, compliance requires strong consistency, or you want the flexibility of both SQL and document queries in one database.", + }, + { + name: "DynamoDB", + bestFor: + "Serverless architectures, single-digit millisecond latency at any scale, AWS Lambda integration, simple key-value access patterns", + why: "Fully managed with zero operational overhead. Single-digit millisecond reads at any scale. Pay-per-request pricing aligns with serverless economics. DynamoDB Streams enable event-driven architectures natively.", + useWhen: + "Your access patterns are well-defined and key-value oriented, you're building serverless on AWS, or you need guaranteed low latency at any scale without capacity planning.", + }, + ], + bottomNote: ( + <> + The choice depends on access patterns, not brand preference.{" "} + + MongoDB + {" "} + for flexible documents,{" "} + + PostgreSQL + {" "} + for relational integrity, DynamoDB for serverless key-value at scale. + We regularly architect systems using multiple databases, each handling + the access pattern it was designed for. + + ), + }, + java: { + sectionId: "java-vs-alternatives", + title: "Java vs .NET vs Node.js:", + highlight: "When You Need What", + subtitle: "We build across all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "Java (Spring Boot)", + bestFor: + "Large-scale distributed systems, financial services, Android backends, organizations with JVM infrastructure", + why: "The JVM is the most battle-tested runtime for distributed computing. Spring Boot's ecosystem covers every enterprise pattern: CQRS, event sourcing, microservices, batch processing. Virtual threads (Project Loom) bring modern concurrency without callback complexity.", + useWhen: + "You're building large distributed systems, your organization has deep JVM expertise, you need the Spring ecosystem's breadth for enterprise integrations, or you're in financial services where Java is the industry standard.", + }, + { + name: ".NET (C# / ASP.NET Core)", + bestFor: + "Microsoft ecosystem shops, Azure-native deployments, Windows-integrated applications, regulated industries", + why: "First-class Azure integration, native Active Directory support, and excellent tooling. ASP.NET Core benchmarks among the fastest web frameworks. Enterprise agreements bundle cloud discounts with existing Microsoft licensing.", + useWhen: + "Your organization runs on the Microsoft stack (AD, SQL Server, Azure), you need tight Windows integration, or your hiring market has stronger .NET talent than Java talent.", + }, + { + name: "Node.js (TypeScript)", + bestFor: + "Full-stack JavaScript teams, real-time applications, lightweight API services, rapid iteration", + why: "Same language across frontend and backend means shared types, shared validation, and fewer context switches. Event-driven architecture handles I/O-heavy workloads efficiently. Fastest path from idea to production for JavaScript-native teams.", + useWhen: + "Your team is JavaScript/TypeScript-native, you're building real-time features (chat, notifications, live updates), or you want full-stack velocity without the JVM or .NET runtime overhead.", + }, + ], + bottomNote: ( + <> + Java and .NET compete directly for enterprise backends. The choice + often comes down to existing infrastructure and team expertise.{" "} + + Node.js + {" "} + serves a different niche: full-stack velocity for JavaScript teams. For + new microservices where startup time and binary size matter,{" "} + + Go + {" "} + is worth considering. We pick the runtime based on your team's + strengths and the workload's requirements. + + ), + }, + kotlin: { + sectionId: "kotlin-vs-alternatives", + title: "Kotlin vs Swift vs React Native:", + highlight: "When You Need What", + subtitle: "We build with all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "Kotlin (Android + Multiplatform)", + bestFor: + "Native Android apps, Kotlin Multiplatform shared logic, JVM backend services, teams migrating from Java", + why: "Google's recommended language for Android. Jetpack Compose provides modern declarative UI. Kotlin Multiplatform shares business logic across Android, iOS, and backend without forcing a shared UI framework. Full Java interop means gradual migration.", + useWhen: + "You're building an Android app (or Android-first), want to share business logic across platforms while keeping native UIs, or have JVM expertise and want a modern language with null safety and coroutines.", + }, + { + name: "Swift (iOS native)", + bestFor: + "iOS-exclusive apps, deep Apple ecosystem integration, performance-critical mobile experiences", + why: "Swift compiles to native ARM code with zero runtime overhead. SwiftUI provides declarative UI for Apple's entire platform family. HealthKit, ARKit, CarPlay, and visionOS APIs are Swift-first. No abstraction layer between your code and Apple hardware.", + useWhen: + "You're building exclusively for Apple platforms, need deep hardware integration (AR, health, car), or require maximum performance on iOS without any cross-platform compromise.", + }, + { + name: "React Native (Cross-platform)", + bestFor: + "iOS + Android from one JavaScript/TypeScript codebase, code sharing with React web apps, teams with JavaScript expertise", + why: "One codebase, two platforms. React developers can contribute to mobile without learning Swift or Kotlin. The New Architecture (Fabric, TurboModules) eliminates the old performance concerns. Largest mobile framework talent pool by far.", + useWhen: + "Your team is JavaScript-native, you need both platforms with one team and one codebase, or you want to share components and logic between your React web app and mobile app.", + }, + ], + bottomNote: ( + <> + Kotlin for Android-native, Swift for iOS-native, React Native when you + need both from one team. Kotlin Multiplatform sits in between: native + UIs with shared business logic. For pixel-perfect custom UI across + platforms,{" "} + + Flutter + {" "} + is another strong option. We help teams pick the right approach based + on platform priorities, team skills, and long-term maintenance costs. + + ), + }, + swift: { + sectionId: "swift-vs-alternatives", + title: "Swift vs React Native vs Flutter:", + highlight: "When You Need What", + subtitle: "We build with all three. Here's how we decide.", + gridCols: "md:grid-cols-3", + frameworks: [ + { + name: "Swift (iOS native)", + bestFor: + "iOS-exclusive apps, deep Apple platform integration, performance-critical experiences, apps targeting visionOS/watchOS/CarPlay", + why: "Compiles to native ARM with zero abstraction overhead. SwiftUI and UIKit give you full access to every Apple API. Day-one support for new iOS features at every WWDC. No cross-platform framework can match this level of platform integration.", + useWhen: + "Your app is iOS-only (or Apple ecosystem-only), requires deep hardware integration (AR, health sensors, car), or needs to ship new Apple platform features on launch day.", + }, + { + name: "React Native (JavaScript/TypeScript)", + bestFor: + "iOS + Android from one team, JavaScript-native teams, code sharing with React web apps, budget-conscious projects", + why: "One codebase targeting both platforms. React developers can ship mobile without learning new languages. New Architecture delivers near-native performance. Over-the-air updates skip App Store review cycles for non-native changes.", + useWhen: + "You need both platforms and don't want to maintain two native codebases, your team is JavaScript-first, or you want to share UI components and business logic between web and mobile.", + }, + { + name: "Flutter (Dart)", + bestFor: + "Pixel-perfect custom UI on both platforms, animation-heavy apps, mobile + web + desktop from one codebase", + why: "Flutter renders every pixel itself via Impeller. Complete control over visual design without platform constraints. One codebase targeting iOS, Android, web, macOS, Windows, and Linux. Growing talent pool and strong Google backing.", + useWhen: + "Custom UI and brand consistency across platforms is the top priority, you're building for mobile plus web plus desktop from one codebase, or your team is open to Dart.", + }, + ], + bottomNote: ( + <> + Native Swift gives you the best iOS experience at the cost of + iOS-only reach. Cross-platform frameworks trade some platform depth for + broader coverage. For Android-native alongside Swift iOS, pair with{" "} + + Kotlin + {" "} + and consider{" "} + + Kotlin Multiplatform + {" "} + to share business logic. We help teams weigh platform depth against + development velocity based on their actual product requirements. + + ), + }, }; export default function FrameworkComparison({ slug }: { slug: string }) { diff --git a/app/services/[slug]/slug-sections/IntroStatement.tsx b/app/services/[slug]/slug-sections/IntroStatement.tsx index 4a91972..0c9d491 100644 --- a/app/services/[slug]/slug-sections/IntroStatement.tsx +++ b/app/services/[slug]/slug-sections/IntroStatement.tsx @@ -139,6 +139,163 @@ const introStatements: Record = { when the workload demands it. ), + typescript: ( + <> + Procedure is a TypeScript development company that builds type-safe, + maintainable applications across frontend, backend, and full-stack + engagements for enterprises that refuse to ship runtime errors to + production. Since 2016, Procedure's engineers have delivered + TypeScript-first platforms for clients including Setu, Pine Labs, and + Last9, spanning payment dashboards, observability tools, and real-time + APIs. The team pairs TypeScript with{" "} + + React + {" "} + and{" "} + + Node.js + {" "} + for end-to-end type safety from database to UI. + + ), + postgresql: ( + <> + Procedure is a PostgreSQL development company that designs + high-performance relational database architectures for fintech, payments, + and SaaS products where data integrity is non-negotiable. Since 2016, + Procedure's database engineers have built PostgreSQL-backed systems + handling millions of daily transactions for clients including Pine Labs, + KredX, and Setu. The team specializes in schema design, query + optimization, and migration from legacy databases. For the application + layer, we pair PostgreSQL with{" "} + + Node.js + {" "} + or{" "} + + Python + {" "} + backends. + + ), + aws: ( + <> + Procedure is an AWS development company that architects production-grade + cloud infrastructure, serverless systems, and CI/CD pipelines for + companies that need to scale without compromising reliability. Since 2016, + Procedure has delivered AWS solutions across compute, storage, and ML + services for clients including Last9, Setu, and Treebo, managing + infrastructure serving millions of requests daily. Engineers hold AWS + certifications and build with{" "} + + Node.js + + ,{" "} + + Python + + , and{" "} + {/* eslint-disable-next-line @next/next/no-html-link-for-pages */} + + Kubernetes + {" "} + on AWS. + + ), + golang: ( + <> + Procedure is a Go development company that builds high-concurrency + backend services, CLI tools, and cloud-native infrastructure for + engineering teams that need C-level performance with Python-level + productivity. Since 2016, Procedure's Go engineers have delivered + microservices, API gateways, and observability backends for clients + including Last9 and Setu. The team builds Go services that integrate with{" "} + + Node.js + {" "} + frontends and deploy to{" "} + + AWS + {" "} + infrastructure. + + ), + mongodb: ( + <> + Procedure is a MongoDB development company that designs document-oriented + database architectures for products with flexible schemas, rapid iteration + cycles, and high-volume unstructured data. Since 2016, Procedure has + delivered MongoDB-backed platforms for clients including ESPN, KredX, and + Timely, building everything from content management systems to real-time + analytics pipelines. The team pairs MongoDB with{" "} + + Node.js + {" "} + or{" "} + + Python + {" "} + application layers for full-stack delivery. + + ), + java: ( + <> + Procedure is a Java development company that builds enterprise-grade + backend systems, payment processing platforms, and distributed + microservices for organizations where uptime and regulatory compliance are + business-critical. Since 2016, Procedure's Java engineers have + delivered Spring Boot APIs, Kafka-driven event systems, and high-throughput + transaction platforms for clients including Pine Labs and MCLabs. For + modern API layers, we complement Java backends with{" "} + + Node.js + {" "} + or{" "} + + .NET + {" "} + where the architecture demands it. + + ), + kotlin: ( + <> + Procedure is a Kotlin development company that builds modern Android + applications, server-side APIs, and multiplatform solutions for teams + migrating from legacy Java codebases or starting greenfield mobile + projects. Since 2016, Procedure's Kotlin engineers have shipped + native Android apps and backend services for clients including ESPN, + Treebo, and KredX. For teams that need cross-platform mobile delivery, we + evaluate Kotlin Multiplatform alongside{" "} + + React Native + {" "} + based on the product's requirements. Kotlin's full + interoperability with{" "} + + Java + {" "} + means existing enterprise systems integrate without rewrites. + + ), + swift: ( + <> + Procedure is a Swift development company that builds native iOS + applications, watchOS extensions, and Apple ecosystem integrations for + products where platform-native performance and App Store optimization are + hard requirements. Since 2016, Procedure has shipped Swift applications in + fintech, media, and consumer verticals for clients including ESPN and + Timely. For teams that need both iOS and Android from a single codebase, + we evaluate cross-platform alternatives including{" "} + + React Native + {" "} + and{" "} + + Flutter + + . + + ), }; export default function IntroStatement({ slug }: { slug: string }) { diff --git a/app/services/[slug]/slug-sections/TechDecisionTable.tsx b/app/services/[slug]/slug-sections/TechDecisionTable.tsx index 9447b4b..dc1530f 100644 --- a/app/services/[slug]/slug-sections/TechDecisionTable.tsx +++ b/app/services/[slug]/slug-sections/TechDecisionTable.tsx @@ -343,6 +343,433 @@ const dataMap: Record = {

), }, + typescript: { + sectionId: "fit", + title: "Is TypeScript Right for Your", + highlight: "Project?", + subtitle: "Type safety is a spectrum. Here's when to go all in.", + cards: [ + { + label: "Codebases with 3+ developers", + description: + "Types serve as living documentation. New developers read the interfaces and understand the data flow without digging through implementation. Refactoring across a large codebase goes from terrifying to routine.", + }, + { + label: "APIs and shared contracts (frontend + backend)", + description: + "Shared types between your React frontend and Node.js backend catch mismatches at compile time, not in production. One schema change propagates everywhere instantly.", + }, + { + label: "Long-lived applications (2+ year lifespan)", + description: + "Code you wrote six months ago is code you forgot. TypeScript's compiler catches the errors your memory won't. Maintenance costs drop significantly on typed codebases.", + }, + { + label: "Enterprise and regulated environments", + description: + "Static analysis satisfies compliance requirements that dynamic languages can't. Type coverage is measurable, auditable, and enforceable in CI pipelines.", + }, + ], + bottomNote: ( +

+ For quick scripts, prototypes, or solo projects where speed outweighs + long-term maintenance, plain JavaScript is often faster to ship. For + data science and ML workloads,{" "} + + Python + {" "} + is the better tool. TypeScript adds friction that pays off at scale but + can slow you down on throwaway work. We'll tell you which fits. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + ctaSubtext: + "We\u2019ve shipped 100+ TypeScript projects. We know where it helps and where it gets in the way.", + }, + postgresql: { + sectionId: "fit", + title: "Is PostgreSQL Right for Your", + highlight: "Data Layer?", + subtitle: "The most capable open-source database. But not always the simplest.", + cards: [ + { + label: "Complex relational data with strong consistency", + description: + "ACID transactions, foreign keys, and complex JOINs across dozens of tables. When your data has relationships that matter, PostgreSQL enforces them at the database level, not in application code.", + }, + { + label: "Mixed workloads (relational + JSON + full-text search)", + description: + "JSONB columns with GIN indexes, full-text search with tsvector, PostGIS for geospatial queries. PostgreSQL handles workloads that would otherwise require three separate databases.", + }, + { + label: "Applications requiring regulatory compliance", + description: + "Row-level security, audit logging, and ACID guarantees make compliance audits straightforward. Financial services, healthcare, and government projects choose PostgreSQL for a reason.", + }, + { + label: "High-write transactional systems", + description: + "MVCC handles concurrent reads and writes without locking. Connection pooling with PgBouncer scales to thousands of concurrent transactions. Proven at petabyte scale.", + }, + ], + bottomNote: ( +

+ If your data is primarily document-shaped with no relational needs,{" "} + + MongoDB + {" "} + offers a more natural fit and faster iteration on schema changes. For + pure caching or session storage where persistence is secondary, Redis + is simpler and faster. We architect data layers with the right tool per + workload, not one database for everything. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + ctaSubtext: + "We\u2019ve designed data architectures running PostgreSQL alongside MongoDB and Redis in the same system.", + }, + aws: { + sectionId: "fit", + title: "Is AWS Right for Your", + highlight: "Infrastructure?", + subtitle: "The largest cloud. Not always the simplest choice.", + cards: [ + { + label: "You need breadth of services (200+ and counting)", + description: + "No other cloud matches AWS for service catalog depth. From Lambda to SageMaker to IoT Core, there's a managed service for almost every workload. Less custom infrastructure to build and maintain.", + }, + { + label: "Multi-region, global-scale deployments", + description: + "33 regions, 105 availability zones. CloudFront edge locations in 50+ countries. When your users span continents, AWS's global footprint is unmatched.", + }, + { + label: "Startup-to-enterprise growth trajectory", + description: + "Start on a t3.micro, scale to thousands of instances. AWS credits programs for startups, enterprise support tiers for Fortune 500s. The platform grows with you without re-platforming.", + }, + { + label: "Regulated industries requiring specific compliance", + description: + "FedRAMP, HIPAA, SOC 2, PCI DSS, ISO 27001. AWS has more compliance certifications than any cloud provider. GovCloud regions for federal workloads.", + }, + ], + bottomNote: ( +

+ If your organization is deeply invested in the Microsoft ecosystem + (Active Directory, .NET, SQL Server), Azure provides tighter + integration with less friction. For ML-heavy workloads where TPUs and + Vertex AI are priorities, GCP offers purpose-built infrastructure. The + best cloud is the one your team can operate effectively. We help teams + choose and migrate between all three. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free infrastructure review", + ctaSubtext: + "We\u2019ve architected AWS environments from startup MVPs to enterprise platforms serving millions.", + }, + golang: { + sectionId: "fit", + title: "Is Go Right for Your", + highlight: "Backend?", + subtitle: "Simple language, serious performance. But simplicity has trade-offs.", + cards: [ + { + label: "High-throughput API services and microservices", + description: + "Compiled to native binaries with sub-millisecond cold starts. Goroutines handle tens of thousands of concurrent connections with minimal memory overhead. No runtime, no garbage collection pauses at scale.", + }, + { + label: "Infrastructure and DevOps tooling", + description: + "Kubernetes, Docker, Terraform, Prometheus - the cloud-native ecosystem is built in Go. If you're building infrastructure tooling, you're already in Go's world.", + }, + { + label: "Services where operational simplicity matters", + description: + "Single static binary deployment. No dependency management at runtime. No JVM tuning, no interpreter version conflicts. Copy the binary, run it. That's it.", + }, + { + label: "Teams that value readability over expressiveness", + description: + "Go forces explicit error handling, minimal abstractions, and straightforward control flow. Code written by any Go developer reads the same way. Onboarding new team members takes days, not weeks.", + }, + ], + bottomNote: ( +

+ If your team is JavaScript-native and you need full-stack velocity,{" "} + + Node.js + {" "} + with TypeScript avoids the language switch. For ML and data science + workloads,{" "} + + Python + {" "} + owns the ecosystem. Go's simplicity means fewer abstractions, + which can mean more boilerplate for complex business logic. We'll + tell you when Go is overkill and when it's exactly right. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + ctaSubtext: + "We\u2019ve built Go services handling 50K+ requests/second in production.", + }, + mongodb: { + sectionId: "fit", + title: "Is MongoDB Right for Your", + highlight: "Data Layer?", + subtitle: "The most popular document database. But not every dataset is a document.", + cards: [ + { + label: "Rapidly evolving schemas and product iteration", + description: + "No migrations, no ALTER TABLE. Add fields to documents as your product evolves. MongoDB's flexible schema lets you ship features without waiting for database changes.", + }, + { + label: "Content management and catalog systems", + description: + "Products with varying attributes, CMS entries with dynamic fields, user profiles with optional properties. Document models map naturally to how applications actually use this data.", + }, + { + label: "Real-time analytics and event logging", + description: + "Time-series collections, capped collections for log rotation, and the aggregation pipeline for complex analytics. MongoDB handles high-write event streams with built-in TTL indexes for automatic cleanup.", + }, + { + label: "Horizontal scaling across regions", + description: + "Native sharding distributes data across clusters automatically. Atlas provides multi-region deployments with zone-based sharding. Scale reads and writes independently as your user base grows globally.", + }, + ], + bottomNote: ( +

+ If your data is heavily relational with complex JOINs, foreign key + constraints, and multi-table transactions,{" "} + + PostgreSQL + {" "} + is the better fit. For pure key-value caching or session storage, Redis + is faster and simpler. We design data architectures that use each + database for what it does best, often running MongoDB and PostgreSQL + side by side. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + ctaSubtext: + "We\u2019ve designed MongoDB schemas for applications serving millions of documents per day.", + }, + java: { + sectionId: "fit", + title: "Is Java Right for Your", + highlight: "Backend?", + subtitle: "Three decades of enterprise trust. Still the backbone of serious systems.", + cards: [ + { + label: "Large-scale distributed systems", + description: + "The JVM is the most battle-tested runtime for distributed computing. Spring Cloud, Kafka, and Hadoop all run on Java. When you need microservices communicating reliably at massive scale, Java's ecosystem is unmatched.", + }, + { + label: "Financial services and regulated industries", + description: + "Banks, insurance companies, and healthcare systems run on Java. Strong typing, mature security libraries, and decades of enterprise hardening make compliance audits straightforward.", + }, + { + label: "High-performance backend APIs (Spring Boot)", + description: + "Spring Boot with virtual threads (Project Loom) handles millions of concurrent requests. JIT compilation optimizes hot paths at runtime. Throughput improves the longer your service runs.", + }, + { + label: "Teams with deep JVM expertise", + description: + "Java has one of the largest developer talent pools globally. Mature tooling (IntelliJ, Maven/Gradle, JUnit) and well-understood patterns mean predictable development velocity on large teams.", + }, + ], + bottomNote: ( +

+ If your organization is a Microsoft shop with existing .NET + infrastructure, staying in that ecosystem avoids unnecessary migration + friction. For JavaScript-native teams building full-stack web + applications,{" "} + + Node.js + {" "} + delivers faster iteration. For new microservices where startup time and + memory footprint matter more than ecosystem breadth,{" "} + + Go + {" "} + compiles to smaller, faster binaries. We pick the runtime that fits + your team and workload, not the one with the most history. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + ctaSubtext: + "We\u2019ve built Java backends for fintech platforms processing thousands of transactions per second.", + }, + kotlin: { + sectionId: "fit", + title: "Is Kotlin Right for Your", + highlight: "Project?", + subtitle: "Modern JVM language. Android's default. Increasingly a backend contender.", + cards: [ + { + label: "Android development (Google's recommended language)", + description: + "Kotlin is Android's first-class language. Jetpack Compose, Kotlin Coroutines, and the entire modern Android ecosystem are Kotlin-first. New Android projects that start in Java are already behind.", + }, + { + label: "Backend services on the JVM (Spring Boot, Ktor)", + description: + "Full interoperability with Java means you get the entire Spring ecosystem with concise, null-safe syntax. Ktor provides a lightweight, coroutine-based alternative for microservices.", + }, + { + label: "Kotlin Multiplatform (shared logic across platforms)", + description: + "Share business logic, networking, and data layers between Android, iOS, web, and backend. Not a UI framework, but shared core logic that reduces duplication without forcing a cross-platform UI.", + }, + { + label: "Teams migrating from Java who want modern language features", + description: + "Null safety, coroutines, data classes, extension functions, and sealed classes. Kotlin fixes Java's verbosity while maintaining 100% interop. Migrate file by file, not all at once.", + }, + ], + bottomNote: ( +

+ If you're building exclusively for iOS,{" "} + + Swift + {" "} + is the native choice. For true cross-platform UI from a single + codebase,{" "} + + React Native + {" "} + or{" "} + + Flutter + {" "} + share the UI layer too, not just business logic. For backend-only + services where the JVM ecosystem isn't needed,{" "} + + Go + {" "} + or{" "} + + Node.js + {" "} + may be simpler. We help teams pick the right language for each layer of + their stack. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + }, + swift: { + sectionId: "fit", + title: "Is Swift Right for Your", + highlight: "Project?", + subtitle: "Apple's language. Unmatched on Apple platforms. Limited beyond them.", + cards: [ + { + label: "iOS and macOS applications with native performance", + description: + "Swift compiles to native ARM code with zero runtime overhead. Metal for GPU access, Core ML for on-device AI, ARKit for augmented reality. No cross-platform layer sits between your code and the hardware.", + }, + { + label: "Apps requiring deep Apple ecosystem integration", + description: + "HealthKit, HomeKit, CarPlay, watchOS, visionOS. Apple's frameworks are Swift-first. If your app needs tight integration with Apple hardware and services, Swift is the only production-grade option.", + }, + { + label: "High-performance, low-latency user experiences", + description: + "SwiftUI with async/await delivers smooth 120fps animations on ProMotion displays. Instruments and Xcode profiling tools catch performance issues before users do.", + }, + { + label: "Teams committed to Apple platforms for the long term", + description: + "Apple invests heavily in Swift. Every WWDC brings new APIs, and they're all Swift-first. Building native gives you day-one access to new platform features without waiting for framework bindings.", + }, + ], + bottomNote: ( +

+ If you need Android alongside iOS,{" "} + + Kotlin + {" "} + (with Kotlin Multiplatform for shared logic) or cross-platform + frameworks like{" "} + + React Native + {" "} + and{" "} + + Flutter + {" "} + reduce duplication. Swift on the server exists but hasn't reached + the maturity of Node.js, Go, or Java for backend workloads. We help + teams decide where native Swift pays off and where cross-platform + makes more sense. +

+ ), + ctaHref: "#book-call", + ctaText: "Book a free architecture call", + }, }; export default function TechDecisionTable({ slug }: { slug: string }) { diff --git a/app/services/[slug]/slug-sections/TechIndustries.tsx b/app/services/[slug]/slug-sections/TechIndustries.tsx index d22effa..0499232 100644 --- a/app/services/[slug]/slug-sections/TechIndustries.tsx +++ b/app/services/[slug]/slug-sections/TechIndustries.tsx @@ -302,6 +302,334 @@ const techIndustryData: Record = { }, ], }, + typescript: { + sectionTitle: "Industries We Build TypeScript Applications For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "Type-safe trading platforms, payment APIs, and regulatory reporting systems. TypeScript's strict typing catches financial calculation errors at compile time across full-stack codebases.", + href: "/industries/financial-services", + }, + { + title: "SaaS & Technology", + description: + "Multi-tenant platforms with shared type definitions between frontend and backend. TypeScript monorepos with Zod validation ensure API contract consistency across microservices.", + href: "/industries/saas", + }, + { + title: "Healthcare & Life Sciences", + description: + "HIPAA-compliant patient portals and clinical data systems. Type-safe HL7 FHIR integrations and strict null checks prevent data handling errors in regulated healthcare environments.", + href: "/industries/healthcare", + }, + { + title: "Education & EdTech", + description: + "Learning management systems and assessment platforms with complex state. TypeScript's type inference reduces bugs in real-time collaboration features and grading logic.", + href: "/industries/education", + }, + { + title: "E-commerce & Retail", + description: + "Product catalog APIs, checkout flows, and inventory systems. End-to-end type safety from database queries through API responses to storefront rendering.", + }, + { + title: "Government & Enterprise", + description: + "Large-scale internal tools and citizen-facing portals. TypeScript's refactoring support and self-documenting interfaces help distributed teams maintain complex codebases.", + }, + ], + }, + postgresql: { + sectionTitle: "Industries We Build PostgreSQL Systems For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "ACID-compliant transaction ledgers, audit trails, and regulatory reporting databases. PostgreSQL's row-level security and partitioning handle high-volume financial data with SOC 2 compliance.", + href: "/industries/financial-services", + }, + { + title: "Healthcare & Life Sciences", + description: + "HIPAA-compliant patient record stores, clinical trial databases, and genomics data platforms. PostgreSQL's JSONB and full-text search handle complex medical data models.", + href: "/industries/healthcare", + }, + { + title: "SaaS & Technology", + description: + "Multi-tenant schemas with row-level security, real-time analytics, and time-series data. PostgreSQL extensions like pg_cron and PostGIS power SaaS features at scale.", + href: "/industries/saas", + }, + { + title: "Education & EdTech", + description: + "Student information systems, assessment result stores, and learning analytics databases. Complex relational models for curricula, enrollments, and progress tracking.", + href: "/industries/education", + }, + { + title: "E-commerce & Retail", + description: + "Product catalogs with faceted search, order management systems, and inventory databases. PostgreSQL's GIN indexes and materialized views power fast catalog queries.", + }, + { + title: "Government & Public Sector", + description: + "Citizen record databases, case management systems, and geospatial data platforms. PostGIS extensions enable location-based queries for public infrastructure and service delivery.", + }, + ], + }, + aws: { + sectionTitle: "Industries We Build AWS Systems For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "PCI-DSS compliant payment infrastructure, real-time fraud detection with Lambda, and disaster recovery architectures. AWS GovCloud and dedicated tenancy for regulatory requirements.", + href: "/industries/financial-services", + }, + { + title: "SaaS & Technology", + description: + "Auto-scaling multi-tenant platforms on ECS/EKS, serverless APIs with API Gateway, and CI/CD pipelines with CodePipeline. Cost-optimized architectures that scale with your customer base.", + href: "/industries/saas", + }, + { + title: "Healthcare & Life Sciences", + description: + "HIPAA-eligible services for patient data, medical imaging storage on S3, and HealthLake for FHIR-compliant data lakes. BAA-covered architectures for protected health information.", + href: "/industries/healthcare", + }, + { + title: "Education & EdTech", + description: + "Scalable LMS backends on Fargate, content delivery via CloudFront, and real-time features with AppSync. Elastic infrastructure that handles enrollment spikes without over-provisioning.", + href: "/industries/education", + }, + { + title: "Media & Entertainment", + description: + "Video transcoding with MediaConvert, CDN delivery via CloudFront, and serverless content processing pipelines. S3 Intelligent-Tiering for cost-effective media asset management.", + }, + { + title: "Manufacturing & IoT", + description: + "AWS IoT Core for device management, Kinesis for telemetry ingestion, and SageMaker for predictive maintenance models. Edge computing with Greengrass for factory floor deployments.", + }, + ], + }, + golang: { + sectionTitle: "Industries We Build Go Systems For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "High-throughput payment gateways, real-time risk scoring engines, and order matching systems. Go's concurrency primitives handle thousands of simultaneous transactions with predictable latency.", + href: "/industries/financial-services", + }, + { + title: "SaaS & Technology", + description: + "API gateways, service meshes, and platform infrastructure tools. Go's fast compilation and small binaries make it ideal for CLI tools, microservices, and developer platform backends.", + href: "/industries/saas", + }, + { + title: "Healthcare & Life Sciences", + description: + "HIPAA-compliant data pipelines, medical device integrations, and health record APIs. Go's memory safety and static binaries simplify deployment in regulated healthcare environments.", + href: "/industries/healthcare", + }, + { + title: "Education & EdTech", + description: + "Real-time collaboration backends, WebSocket servers for live classrooms, and content delivery APIs. Go's goroutines efficiently manage thousands of concurrent student connections.", + href: "/industries/education", + }, + { + title: "Infrastructure & DevOps", + description: + "Custom Kubernetes operators, CI/CD pipeline tools, and infrastructure automation. Go is the language of cloud-native tooling, from Docker to Terraform to Prometheus.", + }, + { + title: "Logistics & Supply Chain", + description: + "Real-time tracking services, route optimization APIs, and warehouse management backends. Go's low-latency processing handles high-frequency location updates across global fleets.", + }, + ], + }, + mongodb: { + sectionTitle: "Industries We Build MongoDB Systems For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "Flexible transaction records, customer profile stores, and real-time analytics. MongoDB's document model handles evolving financial product schemas without costly migrations.", + href: "/industries/financial-services", + }, + { + title: "SaaS & Technology", + description: + "Multi-tenant document stores, user activity logs, and feature flag systems. MongoDB Atlas scales horizontally with sharding while the aggregation pipeline powers in-app analytics.", + href: "/industries/saas", + }, + { + title: "Healthcare & Life Sciences", + description: + "Patient record stores with varying schema requirements, clinical event logs, and medical device data. MongoDB's flexible documents model complex, evolving healthcare data standards.", + href: "/industries/healthcare", + }, + { + title: "Education & EdTech", + description: + "Course content repositories, student interaction logs, and adaptive learning data stores. MongoDB's document model naturally represents hierarchical curriculum structures.", + href: "/industries/education", + }, + { + title: "Gaming & Real-time", + description: + "Player profiles, game state persistence, and leaderboard systems. MongoDB's low-latency reads and change streams power real-time multiplayer features and live event tracking.", + }, + { + title: "E-commerce & Retail", + description: + "Product catalogs with variable attributes, shopping cart sessions, and recommendation data. MongoDB handles diverse product schemas without rigid table structures.", + }, + ], + }, + java: { + sectionTitle: "Industries We Build Java Systems For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "Core banking systems, payment processing engines, and regulatory compliance platforms. Java's mature ecosystem with Spring Boot and enterprise-grade JVM performance powers mission-critical financial infrastructure.", + href: "/industries/financial-services", + }, + { + title: "Healthcare & Life Sciences", + description: + "Electronic health record systems, clinical decision support, and claims processing engines. Java's HIPAA-compliant frameworks and long-term stability serve healthcare's stringent reliability requirements.", + href: "/industries/healthcare", + }, + { + title: "SaaS & Technology", + description: + "Enterprise API platforms, event-driven microservices with Spring Cloud, and batch processing systems. Java's thread management and JVM optimization handle sustained high-throughput workloads.", + href: "/industries/saas", + }, + { + title: "Education & EdTech", + description: + "Institutional management systems, enrollment platforms, and assessment engines. Java's enterprise patterns support complex business logic for large-scale educational organizations.", + href: "/industries/education", + }, + { + title: "Insurance & Risk Management", + description: + "Policy administration systems, actuarial calculation engines, and claims workflows. Java's precision arithmetic and enterprise integration patterns handle complex insurance domain logic.", + }, + { + title: "Government & Public Sector", + description: + "Tax processing systems, benefits administration, and inter-agency data exchange platforms. Java's security framework and FedRAMP-compatible libraries meet government compliance mandates.", + }, + ], + }, + kotlin: { + sectionTitle: "Industries We Build Kotlin Applications For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "Mobile banking apps, payment wallets, and investment platforms on Android. Kotlin's null safety and coroutines deliver crash-resistant financial apps with smooth real-time data updates.", + href: "/industries/financial-services", + }, + { + title: "SaaS & Technology", + description: + "Android companion apps and Ktor-based backend services. Kotlin Multiplatform shares business logic between mobile and server, reducing duplication across SaaS product surfaces.", + href: "/industries/saas", + }, + { + title: "Healthcare & Life Sciences", + description: + "Patient-facing Android apps, health monitoring tools, and clinical workflow applications. Kotlin's type safety and Jetpack Compose UI deliver accessible, HIPAA-compliant mobile experiences.", + href: "/industries/healthcare", + }, + { + title: "Education & EdTech", + description: + "Interactive learning apps, campus mobile portals, and offline-capable study tools. Kotlin's concise syntax accelerates development of feature-rich educational Android applications.", + href: "/industries/education", + }, + { + title: "Travel & Hospitality", + description: + "Booking apps, digital concierge tools, and loyalty programs on Android. Kotlin coroutines handle complex async flows for search, booking, and real-time availability updates.", + }, + { + title: "E-commerce & Retail", + description: + "Shopping apps, barcode scanning tools, and in-store associate applications. Jetpack Compose delivers performant product catalogs with smooth animations and gesture navigation.", + }, + ], + }, + swift: { + sectionTitle: "Industries We Build Swift Apps For", + subtitle: + "Domain knowledge that accelerates delivery and reduces risk.", + industries: [ + { + title: "Financial Services & Fintech", + description: + "iOS banking apps, Apple Pay integrations, and investment portfolio trackers. Swift's memory safety and Keychain APIs deliver secure financial experiences with biometric authentication.", + href: "/industries/financial-services", + }, + { + title: "SaaS & Technology", + description: + "Native iOS companion apps, macOS desktop tools, and Apple Watch extensions. SwiftUI enables rapid development across Apple platforms with shared business logic via Swift packages.", + href: "/industries/saas", + }, + { + title: "Healthcare & Life Sciences", + description: + "Patient iOS apps, HealthKit integrations, and clinical trial data collection tools. Swift's CryptoKit and App Transport Security enforce HIPAA-compliant data handling on Apple devices.", + href: "/industries/healthcare", + }, + { + title: "Education & EdTech", + description: + "iPad learning apps, classroom management tools, and interactive textbooks. Swift Playgrounds and ARKit power immersive educational experiences on Apple's education-focused hardware.", + href: "/industries/education", + }, + { + title: "Travel & Hospitality", + description: + "iOS booking apps, digital room keys via NFC, and Apple Wallet boarding passes. Core Location and MapKit deliver context-aware travel experiences with offline map support.", + }, + { + title: "Media & Entertainment", + description: + "Streaming apps with AVFoundation, content creation tools, and social media clients. Swift's performance and Metal framework integration handle media-rich experiences at 120fps.", + }, + ], + }, }; export default function TechIndustries({ slug }: { slug: string }) { diff --git a/app/services/[slug]/slug-sections/WhyTechnology.tsx b/app/services/[slug]/slug-sections/WhyTechnology.tsx index 625fd23..cd9aeaa 100644 --- a/app/services/[slug]/slug-sections/WhyTechnology.tsx +++ b/app/services/[slug]/slug-sections/WhyTechnology.tsx @@ -260,6 +260,255 @@ const whyTechnologyContent: Record = { }, ], }, + typescript: { + sectionTitle: "Why TypeScript for Your Business", + subtitle: "Catch bugs before your users do. Ship with confidence at scale.", + benefits: [ + { + title: "Fewer Production Bugs", + description: + "TypeScript catches type errors at compile time, not in production. Teams that adopt TypeScript report 15-25% fewer bugs reaching QA, which compounds into faster release cycles and lower support costs.", + }, + { + title: "Safer Refactoring", + description: + "When your product evolves, TypeScript's compiler tells you exactly what breaks. Engineers refactor confidently instead of tip-toeing through fragile JavaScript, making large codebases manageable long-term.", + }, + { + title: "Full-stack Consistency", + description: (<>TypeScript runs everywhere JavaScript runs: React frontends, Node.js backends, serverless functions. One language with one type system across your entire stack eliminates an entire class of integration bugs.), + }, + { + title: "Faster Onboarding", + description: + "TypeScript's type annotations serve as living documentation. New engineers understand function signatures, data shapes, and API contracts by reading the code instead of hunting through wikis.", + }, + { + title: "Industry Standard", + description: + "Google, Airbnb, Stripe, and Slack standardized on TypeScript. Over 98% of the top 1,000 npm packages ship TypeScript definitions. You're adopting the default, not the exception.", + }, + ], + }, + postgresql: { + sectionTitle: "Why PostgreSQL for Your Business", + subtitle: "The database that scales from startup to enterprise without compromise.", + benefits: [ + { + title: "ACID Compliance", + description: + "PostgreSQL guarantees data consistency even under high concurrency. For fintech, payments, and healthcare products, this means zero data corruption risk during transaction spikes.", + }, + { + title: "Zero Licensing Costs", + description: + "PostgreSQL is open-source with no per-core or per-user fees. Companies running Oracle or SQL Server migrations to PostgreSQL routinely eliminate six-figure annual licensing costs.", + }, + { + title: "Advanced Query Capabilities", + description: + "Full-text search, JSONB document storage, geospatial queries, and window functions are built in. PostgreSQL handles workloads that typically require multiple specialized databases.", + }, + { + title: "Proven at Scale", + description: (<>Apple, Instagram, and Spotify run critical systems on PostgreSQL. Paired with Node.js or Python application layers, PostgreSQL handles billions of rows without breaking a sweat.), + }, + { + title: "Extension Ecosystem", + description: + "PostGIS for geospatial, TimescaleDB for time-series, pg_vector for AI embeddings. PostgreSQL extends to new workloads through a mature plugin ecosystem instead of requiring database migrations.", + }, + ], + }, + aws: { + sectionTitle: "Why AWS for Your Business", + subtitle: "The cloud platform with more services, more regions, and more uptime.", + benefits: [ + { + title: "Broadest Service Catalog", + description: + "AWS offers 200+ fully managed services covering compute, AI/ML, databases, IoT, and analytics. Your team builds on managed infrastructure instead of operating it, which cuts operational overhead by 40-60%.", + }, + { + title: "Global Reach", + description: + "33 regions and 105 availability zones mean your application runs close to your users everywhere. For products serving the US, India, and EU simultaneously, AWS reduces latency without architectural complexity.", + }, + { + title: "Cost Optimization Tools", + description: + "Reserved instances, spot pricing, and Savings Plans let engineering teams cut compute costs by 30-70%. AWS's cost explorer and right-sizing recommendations make optimization measurable.", + }, + { + title: "Security and Compliance", + description: + "SOC 2, HIPAA, PCI DSS, FedRAMP: AWS holds more compliance certifications than any cloud provider. For regulated industries, that's months of audit preparation you skip.", + }, + { + title: "Cloud-native Ecosystem", + description: ( + <> + Lambda for serverless, ECS and EKS for{" "} + {/* eslint-disable-next-line @next/next/no-html-link-for-pages */} + Kubernetes, + SageMaker for ML. Teams build with{" "} + Node.js and{" "} + Python on AWS + services that scale automatically. + + ), + }, + ], + }, + golang: { + sectionTitle: "Why Go for Your Business", + subtitle: "Built for concurrency. Compiled for speed. Designed for simplicity.", + benefits: [ + { + title: "Concurrency by Design", + description: + "Go's goroutines handle thousands of concurrent operations with minimal memory overhead. For APIs, message brokers, and real-time systems, Go delivers throughput that interpreted languages cannot match.", + }, + { + title: "Fast Compile, Fast Deploy", + description: + "Go compiles to a single static binary in seconds. No dependency management at deploy time, no runtime installation. Your CI/CD pipeline runs faster and your containers are 10-50MB instead of hundreds.", + }, + { + title: "Operationally Simple", + description: + "Go's standard library covers HTTP servers, JSON handling, cryptography, and testing. Teams build production services with fewer dependencies, which means fewer security vulnerabilities and smaller attack surfaces.", + }, + { + title: "Cloud Infrastructure Standard", + description: (<>Docker, Kubernetes, Terraform, and Prometheus are all written in Go. If your team operates cloud-native infrastructure on AWS, Go is the language your tooling already speaks.), + }, + { + title: "Predictable Performance", + description: + "Go's garbage collector pauses for microseconds, not milliseconds. For latency-sensitive services like payment processing and real-time observability, Go provides the consistency that garbage-collected alternatives struggle to deliver.", + }, + ], + }, + mongodb: { + sectionTitle: "Why MongoDB for Your Business", + subtitle: "Flexible schemas for products that evolve faster than your data model.", + benefits: [ + { + title: "Schema Flexibility", + description: + "MongoDB's document model lets your data structure evolve with your product. Adding fields doesn't require migration scripts or downtime, so feature development isn't blocked by database changes.", + }, + { + title: "Developer Productivity", + description: (<>Documents map directly to objects in Node.js and Python. No ORM translation layer, no impedance mismatch. Engineers write less boilerplate and ship features faster.), + }, + { + title: "Horizontal Scaling", + description: + "MongoDB shards natively across commodity hardware. As your data grows from gigabytes to terabytes, you add capacity without re-architecting. This is the scaling model cloud-native products need.", + }, + { + title: "Real-time Analytics", + description: + "MongoDB's aggregation pipeline handles complex analytics queries on operational data. Teams build dashboards and reporting without maintaining a separate analytics database or ETL pipeline.", + }, + { + title: "Atlas Managed Service", + description: + "MongoDB Atlas handles backups, scaling, security patching, and multi-region replication. Your engineers build product features instead of administering database infrastructure.", + }, + ], + }, + java: { + sectionTitle: "Why Java for Your Business", + subtitle: "The enterprise backbone that runs 3 billion devices worldwide.", + benefits: [ + { + title: "Unmatched Enterprise Ecosystem", + description: + "Spring Boot, Hibernate, Apache Kafka, and Elasticsearch: Java's enterprise library ecosystem is the deepest in any language. Whatever integration your system needs, a battle-tested Java library exists for it.", + }, + { + title: "Performance at Scale", + description: + "Java's JVM optimizes code at runtime through JIT compilation. For high-throughput transaction systems processing millions of requests, Java delivers consistent sub-millisecond response times.", + }, + { + title: "Regulatory Readiness", + description: + "Banks, insurance companies, and government agencies have run Java in production for decades. Compliance teams and auditors trust Java stacks, which matters when regulatory approval gates your launch.", + }, + { + title: "Largest Talent Pool", + description: (<>Java consistently ranks as the most-used enterprise language worldwide. Finding experienced Java engineers is easier and more cost-effective than niche alternatives. For Microsoft-stack organizations, .NET is the closest equivalent.), + }, + { + title: "Long-term Maintainability", + description: + "Java's strong typing, mature tooling, and backward compatibility mean codebases stay maintainable across decades. Systems built on Java 8 still run on Java 21 with minimal changes.", + }, + ], + }, + kotlin: { + sectionTitle: "Why Kotlin for Your Business", + subtitle: "Modern Android development with full Java interoperability.", + benefits: [ + { + title: "Google's Preferred Language", + description: + "Google declared Kotlin the preferred language for Android development. New Android APIs, Jetpack libraries, and official samples are Kotlin-first. Building in Kotlin means building with the platform, not against it.", + }, + { + title: "Safer Code, Fewer Crashes", + description: + "Kotlin's null safety eliminates NullPointerExceptions, the single most common cause of Android app crashes. Fewer crashes mean higher app store ratings and better user retention.", + }, + { + title: "Java Interoperability", + description: (<>Kotlin compiles to JVM bytecode and calls Java libraries directly. Teams migrate incrementally, file by file, without rewriting existing Java code. Your current investment in Java infrastructure is preserved.), + }, + { + title: "Concise, Readable Syntax", + description: + "Kotlin requires 30-40% fewer lines of code than equivalent Java. Less code means faster code reviews, fewer bugs, and engineers who spend time on product logic instead of boilerplate.", + }, + { + title: "Multiplatform Potential", + description: (<>Kotlin Multiplatform lets teams share business logic between Android, iOS, and backend. For teams that need maximum native performance across platforms, it's an alternative to React Native worth evaluating.), + }, + ], + }, + swift: { + sectionTitle: "Why Swift for Your Business", + subtitle: "Native iOS performance for products where the Apple experience matters.", + benefits: [ + { + title: "Best iOS Performance", + description: + "Swift compiles to native machine code, delivering the fastest possible execution on iPhone, iPad, and Apple Watch. For media-heavy apps, AR features, and real-time processing, no cross-platform framework matches Swift's speed.", + }, + { + title: "First Access to Apple APIs", + description: + "SwiftUI, ARKit, CoreML, HealthKit, and every new Apple framework ships Swift-first. Your product accesses new iOS capabilities on launch day, not weeks later when wrapper libraries catch up.", + }, + { + title: "Memory Safety", + description: + "Swift's ARC memory management and optional types eliminate entire categories of crashes. Apps built in Swift have measurably lower crash rates, which directly impacts App Store ranking and user retention.", + }, + { + title: "App Store Optimization", + description: + "Native Swift apps launch faster, consume less battery, and feel responsive in ways Apple's review team notices. Apple features native apps more prominently, giving your product better discovery.", + }, + { + title: "Cross-platform When Needed", + description: (<>Swift excels for iOS-first products. When your roadmap requires Android, teams can add React Native or Flutter for the cross-platform layer while keeping Swift for performance-critical iOS features.), + }, + ], + }, }; export default function WhyTechnology({ slug }: { slug: string }) { diff --git a/app/technologies/aws/layout.tsx b/app/technologies/aws/layout.tsx new file mode 100644 index 0000000..a62bd46 --- /dev/null +++ b/app/technologies/aws/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "AWS Development Services | Cloud-Native & Infrastructure", + description: + "AWS development services for cloud-native apps, migrations, serverless architecture, and DevOps. Senior cloud engineers, honest guidance. Talk to the team.", + alternates: { + canonical: "/technologies/aws", + }, + openGraph: { + title: + "AWS Development Services | Cloud-Native & Infrastructure", + description: + "AWS development services for cloud-native apps, migrations, serverless architecture, and DevOps. Senior cloud engineers, honest guidance. Talk to the team.", + type: "website", + url: "/technologies/aws", + images: [ + { + url: "/assets/technologies/aws-development.png", + width: 1200, + height: 630, + alt: "Procedure - AWS Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "AWS Development Services | Cloud-Native & Infrastructure", + description: + "AWS development services for cloud-native apps, migrations, serverless architecture, and DevOps. Senior cloud engineers, honest guidance. Talk to the team.", + images: [ + { + url: "/assets/technologies/aws-development.png", + width: 1200, + height: 630, + alt: "Procedure - AWS Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function AWSLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/aws/page.tsx b/app/technologies/aws/page.tsx new file mode 100644 index 0000000..8f871a1 --- /dev/null +++ b/app/technologies/aws/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function AWSPage() { + const technology = getTechnologyForListing("aws"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/golang/layout.tsx b/app/technologies/golang/layout.tsx new file mode 100644 index 0000000..0405596 --- /dev/null +++ b/app/technologies/golang/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "Go Development Services | Microservices & Cloud-Native APIs", + description: + "Go development services for microservices, cloud-native APIs, and high-performance systems. Senior Go engineers, honest guidance. Talk to the team.", + alternates: { + canonical: "/technologies/golang", + }, + openGraph: { + title: + "Go Development Services | Microservices & Cloud-Native APIs", + description: + "Go development services for microservices, cloud-native APIs, and high-performance systems. Senior Go engineers, honest guidance. Talk to the team.", + type: "website", + url: "/technologies/golang", + images: [ + { + url: "/assets/technologies/golang-development.png", + width: 1200, + height: 630, + alt: "Procedure - Go Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "Go Development Services | Microservices & Cloud-Native APIs", + description: + "Go development services for microservices, cloud-native APIs, and high-performance systems. Senior Go engineers, honest guidance. Talk to the team.", + images: [ + { + url: "/assets/technologies/golang-development.png", + width: 1200, + height: 630, + alt: "Procedure - Go Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function GoLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/golang/page.tsx b/app/technologies/golang/page.tsx new file mode 100644 index 0000000..a15f6ec --- /dev/null +++ b/app/technologies/golang/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function GolangPage() { + const technology = getTechnologyForListing("golang"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/java/layout.tsx b/app/technologies/java/layout.tsx new file mode 100644 index 0000000..b16a85d --- /dev/null +++ b/app/technologies/java/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "Java Development Services | Enterprise & Spring Boot Apps", + description: + "Enterprise Java development services with Spring Boot 3, microservices, and legacy modernization. Senior engineers, production-grade systems. Talk to the team.", + alternates: { + canonical: "/technologies/java", + }, + openGraph: { + title: + "Java Development Services | Enterprise & Spring Boot Apps", + description: + "Enterprise Java development services with Spring Boot 3, microservices, and legacy modernization. Senior engineers, production-grade systems. Talk to the team.", + type: "website", + url: "/technologies/java", + images: [ + { + url: "/assets/technologies/java-development.png", + width: 1200, + height: 630, + alt: "Procedure - Java Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "Java Development Services | Enterprise & Spring Boot Apps", + description: + "Enterprise Java development services with Spring Boot 3, microservices, and legacy modernization. Senior engineers, production-grade systems. Talk to the team.", + images: [ + { + url: "/assets/technologies/java-development.png", + width: 1200, + height: 630, + alt: "Procedure - Java Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function JavaLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/java/page.tsx b/app/technologies/java/page.tsx new file mode 100644 index 0000000..bfec363 --- /dev/null +++ b/app/technologies/java/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function JavaPage() { + const technology = getTechnologyForListing("java"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/kotlin/layout.tsx b/app/technologies/kotlin/layout.tsx new file mode 100644 index 0000000..0d43d8f --- /dev/null +++ b/app/technologies/kotlin/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "Kotlin Development Services | Android & Multiplatform", + description: + "Kotlin development services for native Android apps, Jetpack Compose UI, and Kotlin Multiplatform. Senior engineers, production-grade mobile. Talk to the team.", + alternates: { + canonical: "/technologies/kotlin", + }, + openGraph: { + title: + "Kotlin Development Services | Android & Multiplatform", + description: + "Kotlin development services for native Android apps, Jetpack Compose UI, and Kotlin Multiplatform. Senior engineers, production-grade mobile. Talk to the team.", + type: "website", + url: "/technologies/kotlin", + images: [ + { + url: "/assets/technologies/kotlin-development.png", + width: 1200, + height: 630, + alt: "Procedure - Kotlin Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "Kotlin Development Services | Android & Multiplatform", + description: + "Kotlin development services for native Android apps, Jetpack Compose UI, and Kotlin Multiplatform. Senior engineers, production-grade mobile. Talk to the team.", + images: [ + { + url: "/assets/technologies/kotlin-development.png", + width: 1200, + height: 630, + alt: "Procedure - Kotlin Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function KotlinLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/kotlin/page.tsx b/app/technologies/kotlin/page.tsx new file mode 100644 index 0000000..031bebb --- /dev/null +++ b/app/technologies/kotlin/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function KotlinPage() { + const technology = getTechnologyForListing("kotlin"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/mongodb/layout.tsx b/app/technologies/mongodb/layout.tsx new file mode 100644 index 0000000..f7b03f0 --- /dev/null +++ b/app/technologies/mongodb/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "MongoDB Development Services | NoSQL Database Engineering", + description: + "MongoDB development services for schema design, performance optimization, and Atlas management. Senior engineers, honest guidance. Talk to the team.", + alternates: { + canonical: "/technologies/mongodb", + }, + openGraph: { + title: + "MongoDB Development Services | NoSQL Database Engineering", + description: + "MongoDB development services for schema design, performance optimization, and Atlas management. Senior engineers, honest guidance. Talk to the team.", + type: "website", + url: "/technologies/mongodb", + images: [ + { + url: "/assets/technologies/mongodb-development.png", + width: 1200, + height: 630, + alt: "Procedure - MongoDB Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "MongoDB Development Services | NoSQL Database Engineering", + description: + "MongoDB development services for schema design, performance optimization, and Atlas management. Senior engineers, honest guidance. Talk to the team.", + images: [ + { + url: "/assets/technologies/mongodb-development.png", + width: 1200, + height: 630, + alt: "Procedure - MongoDB Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function MongoDBLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/mongodb/page.tsx b/app/technologies/mongodb/page.tsx new file mode 100644 index 0000000..a452c1b --- /dev/null +++ b/app/technologies/mongodb/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function MongoDBPage() { + const technology = getTechnologyForListing("mongodb"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/postgresql/layout.tsx b/app/technologies/postgresql/layout.tsx new file mode 100644 index 0000000..c25277d --- /dev/null +++ b/app/technologies/postgresql/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "PostgreSQL Development Services | Design & Optimization", + description: + "PostgreSQL development services for schema design, performance optimization, cloud deployment, and migrations. Senior database engineers. Talk to the team.", + alternates: { + canonical: "/technologies/postgresql", + }, + openGraph: { + title: + "PostgreSQL Development Services | Design & Optimization", + description: + "PostgreSQL development services for schema design, performance optimization, cloud deployment, and migrations. Senior database engineers. Talk to the team.", + type: "website", + url: "/technologies/postgresql", + images: [ + { + url: "/assets/technologies/postgresql-development.png", + width: 1200, + height: 630, + alt: "Procedure - PostgreSQL Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "PostgreSQL Development Services | Design & Optimization", + description: + "PostgreSQL development services for schema design, performance optimization, cloud deployment, and migrations. Senior database engineers. Talk to the team.", + images: [ + { + url: "/assets/technologies/postgresql-development.png", + width: 1200, + height: 630, + alt: "Procedure - PostgreSQL Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function PostgreSQLLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/postgresql/page.tsx b/app/technologies/postgresql/page.tsx new file mode 100644 index 0000000..e0d2004 --- /dev/null +++ b/app/technologies/postgresql/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function PostgreSQLPage() { + const technology = getTechnologyForListing("postgresql"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/swift/layout.tsx b/app/technologies/swift/layout.tsx new file mode 100644 index 0000000..c636718 --- /dev/null +++ b/app/technologies/swift/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "Swift Development Services | iOS & Apple Platform Apps", + description: + "Native iOS app development with Swift 6 and SwiftUI. Senior engineers for iPhone, iPad, Apple Watch, and Apple TV apps. Talk to the team.", + alternates: { + canonical: "/technologies/swift", + }, + openGraph: { + title: + "Swift Development Services | iOS & Apple Platform Apps", + description: + "Native iOS app development with Swift 6 and SwiftUI. Senior engineers for iPhone, iPad, Apple Watch, and Apple TV apps. Talk to the team.", + type: "website", + url: "/technologies/swift", + images: [ + { + url: "/assets/technologies/swift-development.png", + width: 1200, + height: 630, + alt: "Procedure - Swift Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "Swift Development Services | iOS & Apple Platform Apps", + description: + "Native iOS app development with Swift 6 and SwiftUI. Senior engineers for iPhone, iPad, Apple Watch, and Apple TV apps. Talk to the team.", + images: [ + { + url: "/assets/technologies/swift-development.png", + width: 1200, + height: 630, + alt: "Procedure - Swift Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function SwiftLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/swift/page.tsx b/app/technologies/swift/page.tsx new file mode 100644 index 0000000..5a3f4eb --- /dev/null +++ b/app/technologies/swift/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function SwiftPage() { + const technology = getTechnologyForListing("swift"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/app/technologies/typescript/layout.tsx b/app/technologies/typescript/layout.tsx new file mode 100644 index 0000000..3c7cd4e --- /dev/null +++ b/app/technologies/typescript/layout.tsx @@ -0,0 +1,52 @@ +import type { Metadata } from "next"; + +export const metadata: Metadata = { + title: + "TypeScript Development Services | Type-Safe Engineering", + description: + "TypeScript development services for migrations, full-stack apps, and enterprise platforms. Strict mode, end-to-end type safety. Talk to senior engineers.", + alternates: { + canonical: "/technologies/typescript", + }, + openGraph: { + title: + "TypeScript Development Services | Type-Safe Engineering", + description: + "TypeScript development services for migrations, full-stack apps, and enterprise platforms. Strict mode, end-to-end type safety. Talk to senior engineers.", + type: "website", + url: "/technologies/typescript", + images: [ + { + url: "/assets/technologies/typescript-development.png", + width: 1200, + height: 630, + alt: "Procedure - TypeScript Development Services", + }, + ], + }, + twitter: { + card: "summary_large_image", + title: + "TypeScript Development Services | Type-Safe Engineering", + description: + "TypeScript development services for migrations, full-stack apps, and enterprise platforms. Strict mode, end-to-end type safety. Talk to senior engineers.", + images: [ + { + url: "/assets/technologies/typescript-development.png", + width: 1200, + height: 630, + alt: "Procedure - TypeScript Development Services", + }, + ], + site: "@procedurehq", + creator: "@procedurehq", + }, +}; + +export default function TypeScriptLayout({ + children, +}: { + children: React.ReactNode; +}) { + return <>{children}; +} diff --git a/app/technologies/typescript/page.tsx b/app/technologies/typescript/page.tsx new file mode 100644 index 0000000..57e186a --- /dev/null +++ b/app/technologies/typescript/page.tsx @@ -0,0 +1,33 @@ +import { notFound } from "next/navigation"; +import { + getTechnologyForListing, + getRelatedExpertiseForListing, +} from "@/lib/content"; +import { JsonLd } from "@/components/seo"; +import { getExpertiseStructuredData } from "@/lib/expertise-schema"; +import ExpertisePageClient from "@/app/services/[slug]/ExpertisePageClient"; +import { ExpertisePageHero } from "@/app/services/[slug]/ExpertisePageHero"; + +export default function TypeScriptPage() { + const technology = getTechnologyForListing("typescript"); + + if (!technology) { + notFound(); + } + + const relatedPages = getRelatedExpertiseForListing( + technology.relatedExpertise || [], + ); + + return ( + <> + + } + /> + + ); +} diff --git a/content/technologies/aws.mdx b/content/technologies/aws.mdx new file mode 100644 index 0000000..5afacfe --- /dev/null +++ b/content/technologies/aws.mdx @@ -0,0 +1,116 @@ +--- +title: "AWS Development Services" +headline: "AWS Development Services" +headlineAccent: "Cloud-Native Apps, Infrastructure & DevOps" +description: "AWS infrastructure, cloud-native applications, and DevOps pipelines built by senior engineers who've shipped for Setu, ESPN, and Pine Labs." +capabilities: + - title: "Cloud-Native AWS Application Development" + description: "Applications designed for AWS from the ground up. ECS Fargate for containerized workloads, Lambda for event-driven processing, API Gateway for managed endpoints, and DynamoDB or Aurora for data. Not lift-and-shift to AWS. We build applications that use AWS services as building blocks, so you pay for what you use and scale without re-architecture." + icon: "globe" + - title: "AWS Migration and Modernization" + description: "Moving on-premise or legacy cloud workloads to AWS. We assess your current architecture, design the target state, and execute the migration with minimal downtime. Monolith-to-microservices refactoring, database migration (RDS, Aurora), and containerization of legacy applications. Parallel running during cutover so rollback is always an option." + icon: "workflow" + - title: "AWS Serverless (Lambda, Step Functions, EventBridge)" + description: "Event-driven systems built on Lambda, Step Functions, EventBridge, SQS, and API Gateway. Functions that execute in milliseconds and cost nothing when idle. We design serverless architectures that handle bursty workloads without cold-start problems. Not everything should be serverless, and we will tell you when containers or EC2 are the better choice." + icon: "bolt" + - title: "Infrastructure as Code (CDK and Terraform)" + description: "Every AWS resource defined in code, versioned in Git, and deployed through CI/CD. We use AWS CDK (TypeScript) for AWS-only environments and Terraform for multi-cloud or hybrid setups. No manual console clicks in production. Infrastructure changes go through the same code review and deployment pipeline as application code." + icon: "layers" + - title: "AWS DevOps & CI/CD Pipelines" + description: "Automated build, test, and deployment pipelines using CodePipeline, CodeBuild, or GitHub Actions with AWS deployment targets. Blue-green deployments on ECS, canary releases on Lambda, and automated rollback on failure. Your team ships to production multiple times a day with confidence, not anxiety." + icon: "chart" + - title: "AWS Cost Optimization & FinOps" + description: "AWS bills analyzed, waste identified, and costs reduced. Right-sizing EC2 instances, converting to Savings Plans or Reserved Instances, eliminating unused resources, and architecting for cost efficiency. We have reduced AWS bills by 30-50% for clients running over-provisioned infrastructure. Cost optimization is an ongoing practice, not a one-time audit." + icon: "document" +technologies: + - AWS Lambda + - ECS / EKS + - RDS / Aurora + - S3 + - CloudFront + - API Gateway + - CDK (TypeScript) + - Terraform + - CodePipeline + - CloudWatch + - EventBridge + - Step Functions + - SQS / SNS + - DynamoDB +relatedExpertise: + - nodejs + - python + - typescript + - java + - golang + - react +process: + - number: 1 + title: "Cloud Assessment and Architecture (1-2 weeks)" + description: "We audit your current infrastructure (or requirements for greenfield), map workloads to AWS services, and design the target architecture. You get a technical proposal covering service selection, networking (VPC design), security (IAM policies, encryption), cost projections, and migration strategy. No implementation until the architecture is validated." + - number: 2 + title: "Infrastructure Foundation (1-3 weeks)" + description: "AWS VPC, subnets, security groups, IAM roles, and core services provisioned via CDK or Terraform. CI/CD pipeline configured. Monitoring and alerting set up with CloudWatch and alarms. The infrastructure foundation is production-grade from the start, not a prototype that needs hardening later." + - number: 3 + title: "AWS Application Migration & Development (4-16 weeks)" + description: "For migrations: workloads moved service by service with parallel running and validation at each step. For new builds: application services deployed iteratively with working environments available from week one. Your team sees real progress in staging, not architecture diagrams." + - number: 4 + title: "Security, Performance, and Cost Review (1-2 weeks)" + description: "AWS Well-Architected Review against all six pillars: operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability. Security audit with IAM policy review, encryption verification, and network access validation. Load testing under production-like conditions." + - number: 5 + title: "Handoff & AWS Operations Transfer" + description: "Complete documentation covering architecture decisions, IaC repositories, deployment runbooks, and operational procedures. Your team manages the AWS environment independently. Optional support retainer for ongoing optimization and incident response, but no lock-in." +engagementModels: + title: "Hire AWS Engineers" + subtitle: "Senior cloud engineers who build production AWS infrastructure from week one." + models: + - title: "Dedicated Engineer" + description: "Engineers with 5+ years building production systems on AWS. Deep experience across compute (Lambda, ECS, EKS), data (RDS, DynamoDB, S3), and networking (VPC, CloudFront, Route 53). Not developers who passed a certification exam. Engineers who have operated production AWS environments." + bestFor: "Ongoing cloud engineering or DevOps work, 3-month minimum engagement" + - title: "Cloud Pod (2-4 Engineers + Lead)" + description: "A team covering application development, infrastructure, and DevOps. Full ownership of AWS architecture, deployment pipelines, monitoring, and cost management. Mixed team of cloud architects and backend engineers." + bestFor: "Full cloud migrations or platform builds, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed-scope engagement for specific AWS projects: migrations, cost optimization audits, or infrastructure modernization. Clear deliverables, timeline, and transparent pricing." + bestFor: "Defined scope like a migration or cost audit, scope-dependent" +faqs: + - question: "How much do AWS development services cost?" + answer: "AWS development costs depend on scope. A cloud migration for a small-to-medium workload (5-15 services) typically runs $30,000 to $80,000. A cloud-native application built on serverless and containers costs $50,000 to $150,000. Enterprise platform builds with multi-account architecture, advanced networking, and compliance requirements can run $150,000 to $400,000+. Procedure offers a free architecture consultation to scope your specific project. AWS infrastructure costs are separate and billed directly by AWS." + - question: "AWS vs Azure vs GCP - which should I choose?" + answer: "AWS has the broadest service catalog and the largest market share (31% of cloud infrastructure). It is the default choice when you need the widest range of managed services or when your team already has AWS experience. Azure is strongest for organizations already invested in Microsoft (Active Directory, Office 365, .NET). GCP excels at data analytics (BigQuery) and machine learning (Vertex AI). For most applications, the choice comes down to existing team expertise and organizational tooling. Procedure builds on all three and recommends based on your specific situation." + - question: "How long does an AWS migration take?" + answer: "An AWS migration timeline depends on workload complexity. A straightforward lift-and-shift of 5-10 services takes 4-8 weeks. A re-architecture from monolith to microservices on AWS takes 12-24 weeks. Enterprise migrations with compliance requirements, data sovereignty constraints, and legacy system dependencies can take 6-12 months. Procedure migrates incrementally, moving one workload at a time with parallel running and validation at each step." + - question: "Serverless vs containers - which should I use on AWS?" + answer: "Serverless (Lambda) works best for event-driven workloads, bursty traffic patterns, and functions that complete in under 15 minutes. You pay per invocation and nothing when idle. Containers (ECS Fargate or EKS) work best for long-running services, workloads with consistent traffic, and applications that need more than 10GB of memory or custom runtimes. Many production systems use both: Lambda for event processing and API endpoints, containers for background workers and stateful services. Procedure designs the architecture based on your workload characteristics." + - question: "How do you optimize AWS costs?" + answer: "AWS cost optimization starts with visibility. Procedure enables Cost Explorer, sets up budgets and alerts, and analyzes spending by service, tag, and account. Common savings include right-sizing over-provisioned EC2 instances (typical 20-40% reduction), converting on-demand to Savings Plans (up to 72% savings), eliminating idle resources, and re-architecting for serverless where appropriate. We have reduced monthly AWS bills by 30-50% for clients spending $10,000-$100,000+ per month. Cost optimization is an ongoing practice built into our operational reviews." + - question: "How do you handle AWS security?" + answer: "Procedure follows AWS Well-Architected Framework security best practices. That means least-privilege IAM policies (no wildcard permissions), encryption at rest and in transit for all data, VPC network isolation with security groups and NACLs, AWS Config rules for compliance monitoring, and CloudTrail for audit logging. For regulated industries, we implement additional controls for SOC 2, HIPAA, or PCI DSS compliance. Security is part of the infrastructure code, not a post-deployment checklist." + - question: "Should we use managed services or self-managed on AWS?" + answer: "Managed services (RDS, Aurora, ECS Fargate, Lambda) reduce operational burden significantly. Your team focuses on application logic instead of patching databases and managing Kubernetes clusters. The tradeoff is slightly higher cost and less configuration flexibility. Procedure recommends managed services as the default for most teams. Self-managed infrastructure (EC2 with custom Postgres, self-hosted Kubernetes) makes sense only when you need specific configurations that managed services cannot provide and your team has dedicated operations capacity." + - question: "Do your engineers have AWS certifications?" + answer: "Procedure's engineers have hands-on production AWS experience spanning Lambda, ECS, RDS, Aurora, CloudFront, CDK, and Terraform. Certifications validate knowledge, but production experience building and operating AWS systems for clients like Setu and Pine Labs is the stronger signal. We prioritize engineers who have debugged production incidents at 2 AM over engineers who passed a multiple-choice exam." +philosophy: + title: "Our Approach to AWS Development" + subtitle: "Cloud done right means infrastructure you can understand, operate, and afford." + blocks: + - title: "Infrastructure as Code, Always" + description: "Every resource in CDK or Terraform. Every change through a pull request. Every deployment automated. If someone needs to click through the AWS console to make a production change, the infrastructure is not properly codified." + - title: "Cost-Aware AWS Architecture" + description: "We design for cost efficiency from the start, not as an afterthought when the bill arrives. Service selection, instance sizing, and scaling policies all factor in cost alongside performance. Your monthly AWS bill should never be a surprise." + - title: "Security as Default, Not Add-On" + description: "Least-privilege IAM, encryption everywhere, network isolation, and audit logging are part of the initial infrastructure template. Security is not a sprint we run before a compliance audit. It is how the infrastructure is built." + - title: "Right-Sized Complexity" + description: "Multi-account organizations, service mesh, and Kubernetes are powerful tools. They are also expensive to operate. We match architectural complexity to your team's operational capacity. A simpler architecture your team can manage beats a sophisticated one that requires dedicated platform engineering." + - title: "Vendor-Aware, Not Vendor-Locked" + description: "We use AWS-native services where they provide clear advantages (Lambda, Aurora, CloudFront) but keep application code portable. Business logic stays in your code, not in AWS-specific constructs. If you ever move to another cloud, the migration path is clear." +cta: + title: "Ready to Discuss Your AWS Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to an AWS Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "AWS Development Services | Cloud-Native & Infrastructure" + description: "AWS development services for cloud-native apps, migrations, serverless architecture, and DevOps. Senior cloud engineers, honest guidance. Talk to the team." +--- diff --git a/content/technologies/golang.mdx b/content/technologies/golang.mdx new file mode 100644 index 0000000..fa308fa --- /dev/null +++ b/content/technologies/golang.mdx @@ -0,0 +1,117 @@ +--- +title: "Go Development Services" +headline: "Go Development Services" +headlineAccent: "High-Performance Microservices & Cloud-Native APIs" +description: "Microservices, CLI tools, and cloud-native systems built by senior engineers who've shipped Go in production for companies like Setu and Last9." +capabilities: + - title: "Go API & Microservices (Gin, Echo, gRPC)" + description: "Go REST and gRPC APIs built with Gin, Echo, or the standard library. We choose the framework based on your requirements: Gin for rapid API development, Echo for middleware-heavy services, or net/http when you want zero dependencies. Every service ships with structured logging, health checks, and graceful shutdown handling." + icon: "globe" + - title: "Go CLI Tools & Developer Tooling" + description: "Production CLI tools built with Cobra and Viper. Single-binary distribution, cross-platform compilation, and proper signal handling. We build internal developer tools, deployment automation, and infrastructure utilities that your team actually uses because they work reliably and start instantly." + icon: "document" + - title: "Cloud-Native Go Services" + description: "Go services designed for Kubernetes, Docker, and serverless environments. Tiny container images (10-20 MB), sub-second startup times, and minimal memory footprints. Go's static compilation means no runtime dependencies, no version conflicts, and no 'works on my machine' issues." + icon: "layers" + - title: "High-Performance Go Systems" + description: "Go systems where latency and throughput matter. Go's goroutine model handles tens of thousands of concurrent connections on modest hardware. We build real-time data processors, high-throughput API gateways, and streaming services where every millisecond counts. When Node.js or Python hit their ceiling, Go is typically the next step." + icon: "bolt" + - title: "Go Concurrent Data Processing" + description: "ETL pipelines, event stream processors, and batch jobs that leverage Go's concurrency primitives. Goroutines and channels make concurrent processing straightforward without the callback complexity of Node.js or the GIL limitations of Python. We design processing pipelines that scale linearly with available cores." + icon: "chart" + - title: "Go Migration & Modernization" + description: "Migrating performance-critical services from Python, Ruby, or Node.js to Go. We identify the services that benefit most from Go's performance characteristics, rewrite them incrementally, and run old and new implementations in parallel until parity is confirmed. Not everything needs to be rewritten. We are honest about which services justify the migration cost." + icon: "workflow" +technologies: + - Go 1.23 + - Gin + - Echo + - gRPC + - Protocol Buffers + - sqlc + - GORM + - Cobra + - Viper + - Docker + - Kubernetes + - GitHub Actions + - PostgreSQL + - Redis + - NATS +relatedExpertise: + - nodejs + - aws + - postgresql + - typescript + - java + - mongodb +process: + - number: 1 + title: "Architecture & Discovery (1-2 weeks)" + description: "We map your system requirements, performance targets, and integration points. You get a technical proposal covering service boundaries, database selection, API design (REST vs gRPC), deployment strategy, and concurrency model. No code written until the architecture is clear." + - number: 2 + title: "API Design & Data Modeling (1-2 weeks)" + description: "API contracts defined in OpenAPI or Protocol Buffers before implementation begins. Database schema designed with sqlc or GORM based on query patterns. If migrating from another language, we map existing API contracts to Go implementations." + - number: 3 + title: "Go Development & Iteration (6-14 weeks)" + description: "Sprint-based Go development with working services shipped every two weeks. Table-driven tests written alongside features. Your team gets access to staging environments from week one. Go's fast compilation means CI runs complete in minutes, not hours." + - number: 4 + title: "Load Testing & Performance Tuning (1-2 weeks)" + description: "We benchmark under realistic traffic patterns using pprof, benchmark tests, and load generators. Goroutine leak detection, memory allocation profiling, and connection pool tuning. Go makes performance profiling straightforward, and we use that to find and fix bottlenecks before they reach production." + - number: 5 + title: "Handoff & Go Team Enablement" + description: "Complete documentation, architecture decision records, and runbooks for every service. Go's simplicity means onboarding new engineers is faster than most languages. Your team owns the system. Optional support retainer available, but no lock-in." +engagementModels: + title: "Hire Go Developers" + subtitle: "Senior Go engineers who write clean, concurrent, production-ready code." + models: + - title: "Dedicated Developer" + description: "Engineers with 3+ years building production Go systems. Full backend capability spanning API design, concurrency patterns, database integration, and cloud infrastructure. Experience with gRPC, microservices, and Kubernetes deployments." + bestFor: "Ongoing backend development, 3-month minimum engagement" + - title: "Team Pod (2-4 Engineers + Lead)" + description: "A self-contained team that owns full service delivery. Architecture, implementation, testing, and deployment covered. The lead handles architecture decisions while engineers focus on building." + bestFor: "Full service or platform ownership, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed-scope engagement with clear deliverables, timeline, and budget. Defined API contracts, agreed milestones, and transparent pricing." + bestFor: "Defined scope with clear deliverables, scope-dependent" +faqs: + - question: "How much does Go development cost?" + answer: "Go development costs depend on scope. A microservice API with 10-15 endpoints typically runs $15,000 to $35,000. A microservices platform with 5-8 services, inter-service communication, and orchestration sits in the $50,000 to $150,000 range. High-performance systems with custom concurrency patterns, real-time processing, and extensive load testing can run $100,000 to $250,000 or more. Our architecture consultation is free and scopes your specific project." + - question: "Go vs Node.js for backend development?" + answer: "Go excels at CPU-bound work, high-concurrency services, and systems where low latency matters. Node.js excels at I/O-bound workloads, rapid API prototyping, and teams with JavaScript expertise. In benchmarks, Go typically handles 5-10x more concurrent requests than Node.js with lower memory usage. However, Node.js has a larger ecosystem of libraries and a lower barrier to entry for teams already using JavaScript. Many production systems use both: Go for performance-critical services and Node.js for API gateways and BFF layers." + - question: "Go vs Rust for systems programming?" + answer: "Go prioritizes simplicity, fast compilation, and developer productivity. Rust prioritizes memory safety without garbage collection and zero-cost abstractions. For most backend services, APIs, and cloud-native applications, Go is the practical choice. It compiles in seconds, has a gentler learning curve, and its garbage collector handles 99% of memory management needs. Rust makes sense for systems where garbage collection pauses are unacceptable: game engines, embedded systems, or ultra-low-latency trading systems. We recommend Go unless your latency requirements are measured in microseconds." + - question: "When should I choose Go for my project?" + answer: "Go is the right choice when you need high concurrency (thousands of simultaneous connections), low memory footprint (containerized microservices), fast startup times (serverless or auto-scaling environments), or strong performance with simple code. Common Go use cases include API gateways, microservices, CLI tools, data pipelines, and DevOps tooling. Go is not ideal for UI-heavy applications, data science workloads, or rapid prototyping where Python or Node.js would be faster to develop with." + - question: "Is Go good for microservices?" + answer: "Go is one of the best languages for microservices. Its static compilation produces single-binary deployments with no runtime dependencies. Container images are typically 10-20 MB versus 200+ MB for Node.js or Python. Startup time is measured in milliseconds, which matters for auto-scaling and serverless. The standard library includes production-grade HTTP, JSON, and concurrency primitives. Docker, Kubernetes, Terraform, and most cloud-native tooling are written in Go for these exact reasons." + - question: "How steep is Go's learning curve?" + answer: "Go is intentionally simple. The language specification fits in a short document. Most experienced developers become productive in Go within 2-4 weeks. The learning curve is not the syntax, which is minimal, but adopting Go's conventions: error handling with explicit returns instead of exceptions, composition over inheritance, and goroutine-based concurrency. Teams coming from Java or C# adapt fastest. Teams from Python or JavaScript need more adjustment to Go's type system and explicit error handling." + - question: "Can Go be used for web applications?" + answer: "Go handles web backends and APIs well. For server-rendered HTML, Go's template library works for simple cases, but it is not comparable to Rails, Django, or Next.js for content-heavy web applications. Go is best used as the API and backend layer, paired with a frontend framework like React or Next.js for the user interface. If you need a full-stack framework with ORM, admin panels, and auth built in, Django or Rails will get you there faster. Go's strength is the service layer behind the frontend." + - question: "How does Go handle concurrency?" + answer: "Go uses goroutines and channels as its core concurrency model. Goroutines are lightweight threads managed by the Go runtime, each using only 2-8 KB of memory versus 1 MB for OS threads. A single Go process can run millions of goroutines. Channels provide safe communication between goroutines without shared memory or locks. This model makes concurrent programming straightforward compared to callback-based (Node.js) or thread-pool (Java) approaches. The race detector built into the Go toolchain catches concurrency bugs during development." +philosophy: + title: "Our Approach to Go Development" + subtitle: "Go rewards simplicity. We write code that reflects that." + blocks: + - title: "Go's Simplicity Is a Feature" + description: "Go's greatest strength is what it leaves out. We write Go that looks like Go: explicit error handling, minimal abstractions, and clear control flow. If a junior engineer cannot read the code and understand what it does, we rewrite it." + - title: "Standard Library First" + description: "Go's standard library is production-grade. We reach for third-party packages only when the standard library genuinely falls short, not out of habit. Fewer dependencies mean fewer security vulnerabilities, fewer version conflicts, and faster builds." + - title: "Concurrency by Design" + description: "We design services around Go's concurrency model from the start, not as an optimization pass later. Goroutines and channels are used where they simplify the code, not as a performance trick. The right concurrency pattern depends on the workload, and we pick accordingly." + - title: "Go Interfaces Over Inheritance" + description: "Go uses composition and interfaces, not class hierarchies. We design service boundaries around small, focused interfaces that make testing straightforward and coupling low. If an interface has more than 3-4 methods, it is probably doing too much." + - title: "Exit-Ready Architecture" + description: "Every system we build can be maintained by your team or a different vendor. Clean service boundaries, documented decisions, and zero proprietary dependencies. You own everything, always." +cta: + title: "Ready to Discuss Your Go Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a Go Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "Go Development Services | Microservices & Cloud-Native APIs" + description: "Go development services for microservices, cloud-native APIs, and high-performance systems. Senior Go engineers, honest guidance. Talk to the team." +--- diff --git a/content/technologies/java.mdx b/content/technologies/java.mdx new file mode 100644 index 0000000..fcdc96b --- /dev/null +++ b/content/technologies/java.mdx @@ -0,0 +1,122 @@ +--- +title: "Java Development Services" +headline: "Java Development Services" +headlineAccent: "Enterprise Systems That Scale" +description: "Enterprise Java applications, Spring Boot microservices, and payment systems built by senior engineers who've shipped for companies like Pine Labs and KredX." +capabilities: + - title: "Enterprise Java Application Development" + description: "Large-scale Java applications built on Spring Boot 3, designed for complex business logic and long-term maintainability. Java domain-driven design, strict layering, and comprehensive test coverage. Systems that handle millions of transactions and stay stable under regulatory scrutiny." + icon: "globe" + - title: "API & Microservices (Spring Boot)" + description: "High-throughput REST and gRPC APIs using Spring Boot 3 and Spring Cloud. Service discovery, circuit breakers, distributed tracing, and centralized configuration. We design service boundaries around business domains, not technical convenience." + icon: "layers" + - title: "Legacy Java Modernization" + description: "Migrate from Java 8/11, Struts, or EJB-based systems to modern Java 21 with Spring Boot 3. Incremental strategies using strangler fig patterns so your system stays live during the transition. No big-bang rewrites." + icon: "workflow" + - title: "Cloud-Native Java (GraalVM & Quarkus)" + description: "Java applications optimized for containers and serverless. GraalVM native images for sub-second startup times and 50-70% lower memory footprint. Quarkus for Kubernetes-native Java when Spring Boot's footprint is too heavy for your infrastructure budget." + icon: "bolt" + - title: "Java Payment & Fintech Systems" + description: "Transaction processing, payment gateway integrations, and financial reconciliation systems. PCI-DSS compliant architecture with audit logging, idempotency, and fault tolerance. Built with the same rigor we bring to [fintech clients](/industries/financial-services) like Pine Labs." + icon: "chart" + - title: "Java Backend for Mobile Apps" + description: "Robust API backends for iOS and Android applications. Spring Boot APIs with proper versioning, push notification services, OAuth 2.1 authentication, and WebSocket support for real-time features. Designed to serve [mobile frontends](/services/mobile-development) at scale." + icon: "document" +technologies: + - Java 21 LTS + - Spring Boot 3 + - Spring Cloud + - Hibernate + - Gradle + - Maven + - JUnit 5 + - Testcontainers + - Docker + - Kubernetes + - AWS + - GraalVM + - Quarkus + - PostgreSQL + - Redis + - Kafka + - RabbitMQ + - OpenTelemetry + - Flyway + - GitHub Actions +relatedExpertise: + - dotnet + - nodejs + - postgresql + - aws + - kotlin + - golang +process: + - number: 1 + title: "Architecture & Discovery (1-2 weeks)" + description: "Map your system requirements, integration points, and scalability targets. Choose between Spring Boot, Quarkus, or a hybrid approach based on actual workload characteristics. Deliverable: architecture decision records, service diagrams, and a technical proposal." + - number: 2 + title: "API Design & Data Modeling (1-2 weeks)" + description: "API contracts documented in OpenAPI before code is written. Database schema designed with Hibernate mappings, migration scripts in Flyway, and proper indexing strategy. Your frontend team can build against mocked endpoints immediately." + - number: 3 + title: "Java Development & Iteration (6-20 weeks)" + description: "Sprint-based Java development with working services shipped every two weeks. JUnit 5 and Testcontainers for reliable automated testing. Staging environments from week one. You review real code, not slide decks." + - number: 4 + title: "Load Testing & Hardening (1-2 weeks)" + description: "Simulate production traffic patterns using Gatling or k6. Connection pool tuning, query optimization, JVM profiling with async-profiler, and caching layer validation. Nothing ships until it handles your expected load with headroom." + - number: 5 + title: "Handoff & Java Team Enablement" + description: "Architecture decision records, Javadoc-generated API documentation, runbooks, and deployment guides. Your team owns the system entirely. Optional support retainer available, but no lock-in." +engagementModels: + title: "Hire Java Developers" + subtitle: "Senior Java engineers who integrate with your team and deliver from week one." + models: + - title: "Dedicated Developer" + description: "Engineers with 5+ years building production Java systems in Spring Boot, Hibernate, and cloud-native environments. Full backend capability spanning API design, database optimization, and infrastructure." + bestFor: "Ongoing enterprise development, 3-month minimum engagement" + - title: "Team Pod (2-4 Engineers + Lead)" + description: "A self-contained team that owns full service delivery. Architecture, implementation, testing, and deployment covered. The lead handles technical decisions and stakeholder communication." + bestFor: "Full platform ownership, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed-scope engagement with clear deliverables, timeline, and budget. Defined service contracts, agreed milestones, and transparent pricing." + bestFor: "Defined scope with clear deliverables, scope-dependent" +faqs: + - question: "What is the typical cost of Java development services?" + answer: "Java development services typically range based on project complexity. API backends with 10-20 endpoints run $20,000 to $50,000. Microservices platforms with 5-10 services sit in the $60,000 to $200,000 range. Full enterprise applications with complex integrations, compliance requirements, and transaction processing can run $150,000 to $500,000+. Dedicated Java developer hiring starts at $4,000/month. We provide detailed estimates after a free architecture consultation." + - question: "Java vs Node.js for backend development?" + answer: "Java excels at CPU-intensive workloads, complex domain logic, and systems where type safety and compile-time guarantees reduce production incidents. Node.js excels at I/O-heavy concurrent workloads like real-time APIs and event-driven microservices. Java's JVM offers better throughput for computation-heavy services, while Node.js handles concurrent connections more efficiently for lightweight API gateways. Many modern platforms use both: Java for core business services and Node.js for the API gateway layer." + - question: "Java vs .NET for enterprise applications?" + answer: "Both are strong enterprise choices. Java offers broader ecosystem diversity (Spring, Quarkus, Micronaut), runs on any OS without vendor dependency, and has the largest enterprise developer talent pool globally. .NET provides tighter Microsoft ecosystem integration (Azure, Active Directory, SQL Server) and a faster development pace for teams already in the Microsoft stack. Choose Java when vendor independence, cross-platform deployment, or a larger hiring pool matters. Choose .NET when Microsoft ecosystem integration is a priority." + - question: "Spring Boot vs Jakarta EE for new projects?" + answer: "Spring Boot 3 is the standard choice for most new Java projects in 2026. It offers faster development velocity, a massive ecosystem of starters and integrations, and strong community support. Jakarta EE (formerly Java EE) still makes sense for organizations with existing Jakarta investments or those needing vendor-portable enterprise specs. Spring Boot's opinionated defaults get you to production faster, while Jakarta EE gives you specification-level portability." + - question: "How do you approach legacy Java modernization?" + answer: "Legacy Java modernization follows an incremental strategy. We start by assessing the existing codebase: identifying tightly coupled components, missing test coverage, and outdated dependencies. Then we apply strangler fig patterns to migrate services piece by piece while keeping the system live. Typical modernization from Java 8 to Java 21 with Spring Boot 3 takes 3-8 months depending on system size. We write tests first to create a safety net, then migrate module by module." + - question: "Is Java still a good choice for startups?" + answer: "Java with Spring Boot 3 is a strong startup choice when the product involves complex business logic, financial transactions, or enterprise customers who expect robust, scalable systems. The JVM's mature tooling, extensive library ecosystem, and large talent pool reduce technical risk. Startups building simpler web APIs or consumer apps may iterate faster with Node.js or Python initially. We help startups choose the right stack based on their specific product requirements, not language popularity." + - question: "How does Java performance compare in 2026?" + answer: "Modern Java 21 with virtual threads (Project Loom) handles millions of concurrent connections with dramatically simpler code than traditional thread pool models. GraalVM native images achieve sub-second cold starts and 50-70% lower memory usage, making Java competitive with Go and Rust for containerized workloads. The ZGC garbage collector delivers sub-millisecond pause times even with large heaps. Java is no longer the memory-hungry, slow-starting runtime it was a decade ago." + - question: "How do you handle Java developer hiring and team scaling?" + answer: "Procedure provides senior Java engineers who integrate directly with your team, using your repositories, tools, and sprint cadence. Engineers have 5+ years of production Java experience and are proficient in Spring Boot 3, cloud infrastructure, and modern Java features (records, sealed classes, virtual threads). Teams can start within 2-5 business days and scale up or down based on project needs. No long-term contracts required to begin." +philosophy: + title: "Our Approach to Java Development" + subtitle: "Enterprise Java that earns its complexity through production demands, not habit." + blocks: + - title: "Modern Java, Not Legacy Patterns" + description: "Java 21 records, sealed classes, pattern matching, and virtual threads are not optional extras. We use modern Java features to write cleaner, more maintainable code. If your codebase still looks like Java 8, something is wrong." + - title: "Right-Sized Java Architecture" + description: "Not every system needs 50 microservices. Not every application belongs in a monolith. We size services based on team boundaries, deployment frequency, and scaling requirements. Architecture follows organizational reality, not conference talks." + - title: "Test Coverage as Confidence" + description: "JUnit 5 and Testcontainers are part of every project from day one. We write tests that verify business behavior, not implementation details. Test coverage exists to give teams confidence to change code, not to hit a number." + - title: "Observable Java Services by Default" + description: "Structured logging with SLF4J, distributed tracing with OpenTelemetry, and health checks are baked into the initial scaffold. When something breaks in production, the first question should be 'what happened,' not 'how do we find out.'" + - title: "Ownership Transfer Built In" + description: "Every Java system we build can be maintained by your team independently. Clean architecture, documented decisions, and zero proprietary dependencies. We build for your future, not our recurring revenue." +cta: + title: "Ready to Discuss Your Java Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a Java Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "Java Development Services | Enterprise & Spring Boot Apps" + description: "Enterprise Java development services with Spring Boot 3, microservices, and legacy modernization. Senior engineers, production-grade systems. Talk to the team." +--- diff --git a/content/technologies/kotlin.mdx b/content/technologies/kotlin.mdx new file mode 100644 index 0000000..0b18183 --- /dev/null +++ b/content/technologies/kotlin.mdx @@ -0,0 +1,121 @@ +--- +title: "Kotlin Development Services" +headline: "Kotlin Development Services" +headlineAccent: "Native Android & Multiplatform" +description: "Native Android apps, Kotlin Multiplatform projects, and server-side Kotlin built by senior engineers who ship production mobile and backend systems." +capabilities: + - title: "Native Android Development with Kotlin" + description: "Production Android applications built with Kotlin, Jetpack Compose, and modern Android architecture (MVVM, MVI). Material 3 design, adaptive layouts for phones, tablets, and foldables. Apps that follow Google's current best practices, not patterns from five years ago." + icon: "globe" + - title: "Kotlin Multiplatform (KMP)" + description: "Share business logic across Android, iOS, web, and desktop without rewriting it per platform. KMP lets you write networking, data models, validation, and caching once in Kotlin, then use native UI on each platform. Google officially recommends KMP for cross-platform business logic as of 2024." + icon: "layers" + - title: "Server-Side Kotlin (Ktor, Spring Boot)" + description: "Backend services in Kotlin using Ktor or Spring Boot. Coroutines for efficient concurrent request handling without callback complexity. Kotlin's null safety and expressive syntax reduce production bugs compared to Java backends. Ideal when your Android team also owns backend services." + icon: "chart" + - title: "Android App Modernization (Java to Kotlin)" + description: "Migrate existing Android apps from Java to Kotlin incrementally. Kotlin is 100% interoperable with Java, so migration happens file by file without breaking the build. We prioritize high-change areas first to maximize the return on migration effort. Most apps complete migration in 8-16 weeks." + icon: "workflow" + - title: "Jetpack Compose UI" + description: "Kotlin declarative UI for Android that replaces XML layouts with composable Kotlin functions. Less boilerplate, better state management, built-in animation APIs, and Material 3 support. Compose is Google's recommended approach for all new Android UI and powers apps like Google Maps and Play Store." + icon: "bolt" + - title: "Kotlin SDK & Library Development" + description: "Custom Android SDKs, payment integrations, and shared libraries for distribution via Maven Central or private repositories. Proper API design, backward compatibility, semantic versioning, and documentation. Built for other developers to consume without frustration." + icon: "document" +technologies: + - Kotlin 2.1 + - Jetpack Compose + - Kotlin Multiplatform + - Ktor + - Coroutines + - Room + - Hilt + - Gradle + - Firebase + - Android Studio + - Material 3 + - Compose Navigation + - DataStore + - WorkManager + - Koin + - SQLDelight + - Detekt + - JUnit 5 + - Espresso +relatedExpertise: + - react-native + - flutter + - java + - swift + - nodejs + - typescript +process: + - number: 1 + title: "Discovery & Architecture (1-2 weeks)" + description: "Define screens, user flows, and technical approach. Choose between Jetpack Compose (Android-only) and KMP (multiplatform). If you have an existing Java Android app, we audit it and plan the migration path. Deliverable: technical spec, architecture diagram, and Figma wireframes." + - number: 2 + title: "Design System & Component Library (1-2 weeks)" + description: "Build a custom Compose component library implementing your brand's design language. Material 3 theming, dynamic color support, and adaptive layouts for different screen sizes. Components tested in isolation with Compose Preview and screenshot tests." + - number: 3 + title: "Kotlin Development & Iteration (6-16 weeks)" + description: "Sprint-based Kotlin development with internal builds distributed via Firebase App Distribution for real-device testing. Weekly demos. Kotlin's concise syntax and Compose's declarative model mean faster iteration than traditional Android development." + - number: 4 + title: "QA, Performance & Launch (1-2 weeks)" + description: "Testing across phones, tablets, and foldables. Compose UI tests, integration tests, and performance profiling with Android Studio's Layout Inspector and baseline profiles. Play Store submission with proper listing optimization." + - number: 5 + title: "Post-Launch & Kotlin App Maintenance" + description: "Bug fixes, Android OS compatibility updates (Android 16 targeted), feature development, and Play Store policy compliance. Ongoing performance monitoring with Firebase Crashlytics and Performance Monitoring." +engagementModels: + title: "Hire Kotlin Developers" + subtitle: "Senior Kotlin engineers with production Android and multiplatform experience." + models: + - title: "Dedicated Developer" + description: "Full-time on your project, integrated into your team. Engineers proficient in Kotlin 2.1, Jetpack Compose, KMP, and modern Android architecture patterns." + bestFor: "Ongoing Android development, 3-month minimum engagement" + - title: "Team Pod (2-4 Engineers + Lead)" + description: "Android + backend + QA for a complete mobile team. Architecture, implementation, testing, and Play Store deployment covered." + bestFor: "Full product ownership, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed scope, milestone-based delivery. Defined specs, agreed milestones, and transparent pricing." + bestFor: "Defined scope with clear deliverables, scope-dependent" +faqs: + - question: "How much does Kotlin Android app development cost?" + answer: "Kotlin app development costs vary by complexity. Simple apps with standard UI run $15,000 to $40,000. Mid-complexity apps (e-commerce, social, data-heavy) range from $40,000 to $120,000. Enterprise Android apps with offline support, SSO, and compliance features run $120,000 to $300,000+. Dedicated Kotlin developer hiring starts at $3,500/month. KMP projects that share logic across iOS and Android typically cost 20-30% less than building separate native apps." + - question: "Kotlin vs Java for Android development?" + answer: "Kotlin is Google's recommended language for Android development. All new Android APIs, Jetpack libraries, and documentation prioritize Kotlin. Kotlin offers null safety (eliminating the most common crash category), coroutines for async work (simpler than Java's thread management), and 30-40% less boilerplate code. Java still works on Android, but new Android features ship Kotlin-first. If you're starting a new Android project in 2026, Kotlin is the clear choice." + - question: "Kotlin Multiplatform vs React Native for cross-platform?" + answer: "Kotlin Multiplatform (KMP) shares business logic while keeping native UI on each platform. React Native shares both logic and UI through a JavaScript bridge. KMP produces genuinely native apps with no runtime abstraction layer, resulting in better performance and full access to platform APIs. React Native offers faster UI development through a single shared component layer. Choose KMP when performance, native feel, and platform API access matter most. Choose React Native when development speed and a shared UI are priorities." + - question: "How long does Java to Kotlin migration take for an Android app?" + answer: "Migration timeline depends on app size and test coverage. A small app (20-50 files) typically takes 4-8 weeks. Medium apps (50-150 files) take 8-16 weeks. Large enterprise apps (150+ files) take 3-6 months. Kotlin is 100% interoperable with Java, so migration happens incrementally, file by file, without breaking the build. We prioritize high-change areas first so your team benefits from Kotlin's advantages where they write the most code." + - question: "Is Kotlin suitable for backend/server-side development?" + answer: "Kotlin is a strong choice for server-side development, especially when your team already uses Kotlin for Android. Ktor provides a lightweight, coroutine-native framework for building APIs. Spring Boot has full Kotlin support with dedicated extensions. Kotlin's coroutines handle concurrent requests efficiently without the complexity of reactive frameworks. Companies like Square, Trello, and Atlassian use Kotlin on the server. It makes particular sense when your Android and backend teams share code through KMP." + - question: "What is Jetpack Compose and should we adopt it?" + answer: "Jetpack Compose is Android's modern declarative UI toolkit that replaces XML layouts with Kotlin functions. Google recommends Compose for all new Android UI development. It offers less boilerplate (50-70% less UI code than XML), built-in animation APIs, better state management, and Material 3 support out of the box. Google Maps, Play Store, and most new Google apps use Compose. If you're building a new Android app or planning a UI refresh, Compose is the right choice." + - question: "Can you train our existing team on Kotlin?" + answer: "We offer structured knowledge transfer as part of every engagement. Engineers pair-program with your team, conduct code reviews, and document architectural patterns. For formal training, we run hands-on workshops covering Kotlin fundamentals, Jetpack Compose, coroutines, and KMP. Most Java Android developers become productive in Kotlin within 2-4 weeks given the language similarities and strong IDE support in Android Studio." + - question: "Which Android versions do you support?" + answer: "We typically target Android 8.0 (API 26) as the minimum, which covers 95%+ of active Android devices. The app targets the latest Android 16 SDK as required by Play Store policies. We test on a range of devices including budget phones, mid-range devices, tablets, and foldables. Adaptive layouts using Compose's WindowSizeClass ensure proper display across all screen sizes." +philosophy: + title: "Our Approach to Kotlin Development" + subtitle: "Modern Android engineering, not legacy patterns wrapped in a new language." + blocks: + - title: "Kotlin-First, Not Kotlin-Translated" + description: "Writing Java patterns in Kotlin syntax misses the point. We use Kotlin idioms: sealed classes for state modeling, coroutines for async work, extension functions for clean APIs, and data classes for immutable models. The code should feel like Kotlin, not Java wearing a Kotlin costume." + - title: "Compose as the UI Standard" + description: "Jetpack Compose is not optional for new projects. XML layouts, Fragments, and the View system are legacy patterns. We build with Compose from day one: composable functions, unidirectional data flow, and declarative state management. The result is less code, fewer bugs, and faster development." + - title: "Kotlin Shared Logic, Native Experience" + description: "When using KMP, business logic lives in shared Kotlin modules. UI stays native to each platform. We resist the temptation to share UI across platforms because users notice when an app does not feel native. Shared logic, native UX." + - title: "Testing That Catches Real Bugs" + description: "Compose UI tests, integration tests with real dependencies, and screenshot tests for visual regression. We test user behavior, not implementation details. A test suite should give your team confidence to ship changes, not slow them down with false positives." + - title: "Kotlin Team Ownership from Day One" + description: "Every Kotlin project is built so your team can maintain it independently. Clean architecture, documented decisions, automated CI/CD, and zero proprietary tooling. We build for your engineers, not our retention." +cta: + title: "Ready to Discuss Your Kotlin Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a Kotlin Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "Kotlin Development Services | Android & Multiplatform" + description: "Kotlin development services for native Android apps, Jetpack Compose, and Kotlin Multiplatform. Senior engineers, production mobile. Talk to the team." +--- diff --git a/content/technologies/mongodb.mdx b/content/technologies/mongodb.mdx new file mode 100644 index 0000000..8db731f --- /dev/null +++ b/content/technologies/mongodb.mdx @@ -0,0 +1,116 @@ +--- +title: "MongoDB Development Services" +headline: "MongoDB Development Services" +headlineAccent: "Scalable NoSQL Database Engineering" +description: "Schema design, performance optimization, and MongoDB infrastructure built by senior engineers who've shipped for companies like Setu, ESPN, and KredX." +capabilities: + - title: "MongoDB Schema Design & Document Modeling" + description: "Document schema design that balances read performance, write efficiency, and storage costs. We model your data around actual query patterns, not relational instincts. Embedding vs referencing, denormalization strategies, and polymorphic patterns designed for how your application actually accesses data, not how an ER diagram looks on a whiteboard." + icon: "layers" + - title: "MongoDB Performance Optimization & Indexing" + description: "Slow MongoDB queries found and fixed. We analyze query plans with explain(), design compound indexes that cover your most frequent operations, and eliminate collection scans. Index strategy is not just adding indexes to every field. We balance read speed against write overhead and storage impact. Typical result: 10-50x improvement on poorly indexed collections." + icon: "chart" + - title: "MongoDB Atlas Management" + description: "Full Atlas lifecycle management: cluster sizing, tier selection, backup configuration, network security, and cost optimization. We configure auto-scaling rules that match your traffic patterns, set up monitoring alerts, and implement access controls with database-level RBAC. If you are overpaying for your Atlas tier, we will find it." + icon: "globe" + - title: "MongoDB Aggregation Pipelines & Analytics" + description: "Complex data transformations, reporting queries, and analytics built with MongoDB's aggregation framework. We design pipelines that handle grouping, lookups, windowing, and statistical operations without requiring a separate analytics database. For full-text and vector search, we integrate Atlas Search and Atlas Vector Search directly into your query layer." + icon: "document" + - title: "Migration to MongoDB" + description: "Incremental migration from relational databases (PostgreSQL, MySQL, SQL Server) to MongoDB. We map relational schemas to document models, build data migration scripts with validation, and run dual-write patterns during transition. No big-bang cutovers. Your application stays live throughout. Typical migration: 4-12 weeks depending on data volume and complexity." + icon: "workflow" + - title: "MongoDB Change Streams & Real-Time Data" + description: "Event-driven architectures using MongoDB Change Streams. We build real-time notification systems, cache invalidation pipelines, and cross-service data synchronization triggered by database changes. Change Streams provide at-least-once delivery with resume tokens for fault tolerance, no separate message broker required for many use cases." + icon: "bolt" +technologies: + - MongoDB 8.0 + - MongoDB Atlas + - Mongoose + - Prisma + - MongoDB Compass + - Atlas Search + - Atlas Vector Search + - Change Streams + - AWS DocumentDB + - Node.js + - Python + - Go + - Redis + - Docker +relatedExpertise: + - nodejs + - python + - typescript + - aws + - react + - golang +process: + - number: 1 + title: "Data Modeling & Discovery (1-2 weeks)" + description: "We analyze your data access patterns, query frequency, and growth projections. You get a schema design document covering collection structure, indexing strategy, embedding vs referencing decisions, and sharding considerations. No implementation until the data model is validated against your actual workloads." + - number: 2 + title: "Schema Design & Index Planning (1-2 weeks)" + description: "Document schemas designed and validated with sample data. Compound indexes planned based on query patterns identified in discovery. Migration strategy defined if moving from a relational database. Atlas cluster configuration specified for your traffic and storage requirements." + - number: 3 + title: "MongoDB Development & Integration (6-14 weeks)" + description: "Sprint-based MongoDB development with working endpoints and database operations shipped every two weeks. Data access layer built with Mongoose or Prisma based on your stack. Aggregation pipelines developed and performance-tested against realistic data volumes. Your team gets staging access from week one." + - number: 4 + title: "Performance Testing & Optimization (1-2 weeks)" + description: "We load test with production-scale data volumes, analyze slow query logs, and tune indexes and aggregation pipelines. Connection pool sizing, read preference configuration, and write concern tuning based on your consistency requirements. Nothing ships until queries meet your latency targets." + - number: 5 + title: "Handoff & MongoDB Operations Transfer" + description: "Complete documentation covering schema decisions, indexing rationale, operational runbooks, and monitoring setup. Your team owns the database architecture. Optional support retainer for ongoing optimization, but no lock-in." +engagementModels: + title: "Hire MongoDB Developers" + subtitle: "Senior engineers who design schemas that scale and queries that perform." + models: + - title: "Dedicated Developer" + description: "Engineers with 3+ years building production MongoDB systems. Full database capability spanning schema design, query optimization, aggregation pipelines, and Atlas management. Backend development experience in Node.js, Python, or Go included." + bestFor: "Ongoing development with MongoDB backend, 3-month minimum engagement" + - title: "Team Pod (2-4 Engineers + Lead)" + description: "A self-contained team that owns your MongoDB-backed application end to end. Schema design, API development, performance optimization, and deployment covered." + bestFor: "Full application ownership with MongoDB, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed-scope engagement with clear deliverables, timeline, and budget. Defined schema design, agreed milestones, and transparent pricing." + bestFor: "Database migration or optimization projects, scope-dependent" +faqs: + - question: "How much do MongoDB development services cost?" + answer: "MongoDB development costs depend on scope. Schema design and optimization for an existing application typically runs $10,000 to $30,000. A full application backend with MongoDB, including API layer and data modeling, sits in the $40,000 to $120,000 range. Enterprise platforms with sharding, Atlas Search integration, and complex aggregation pipelines can run $100,000 to $250,000 or more. Our initial architecture consultation is free." + - question: "MongoDB vs PostgreSQL: which should I use?" + answer: "MongoDB excels when your data is hierarchical, semi-structured, or varies between records. Product catalogs with different attributes per category, user activity logs, content management systems, and IoT data are strong fits. PostgreSQL excels when your data is highly relational, you need complex joins across many tables, or you require strict ACID transactions across multiple entities. Many production systems use both: MongoDB for flexible document storage and PostgreSQL for relational data with foreign key constraints. We help you choose based on your data shape and query patterns." + - question: "When should I use MongoDB?" + answer: "MongoDB is the right choice when your data model is document-oriented (nested objects, arrays, varying fields), when you need horizontal scaling across large datasets, when schema flexibility matters (rapidly evolving data structures), or when read-heavy workloads dominate. Common MongoDB use cases include content management, product catalogs, user profiles, real-time analytics, and IoT data ingestion. MongoDB is not ideal for heavily relational data with many cross-entity joins or systems requiring multi-document ACID transactions across different collections." + - question: "How does MongoDB scale?" + answer: "MongoDB scales vertically (larger instances) and horizontally (sharding). Atlas auto-scaling adjusts compute and storage based on demand. For horizontal scaling, MongoDB distributes data across shards using a shard key you define. Choosing the right shard key is critical. A poor choice leads to hot spots where one shard handles most traffic. We design shard keys based on your actual query and write patterns, not default recommendations. Most applications under 500 GB of data do not need sharding. Vertical scaling and proper indexing handle the load at lower operational complexity." + - question: "MongoDB Atlas vs self-hosted: which is better?" + answer: "Atlas is the right choice for most teams. It handles backups, patching, monitoring, scaling, and security updates automatically. The operational burden of self-hosted MongoDB is significant: replica set management, backup verification, security patches, and version upgrades. Atlas costs more per GB than self-hosted, but the total cost of ownership is typically lower when you account for DevOps time. Self-hosted makes sense when you have strict data residency requirements, need to run on specific infrastructure, or have an experienced DBA team already managing databases. We deploy on both and recommend based on your team and compliance needs." + - question: "How do you approach MongoDB schema design?" + answer: "Procedure designs MongoDB schemas around query patterns, not entity relationships. We start by listing every query your application will execute, then design document structures that serve those queries efficiently. This often means embedding related data in a single document rather than normalizing across collections. We apply patterns like the bucket pattern for time-series data, the outlier pattern for documents with variable-size arrays, and the computed pattern for pre-aggregated analytics. Every schema decision is documented with the reasoning behind it." + - question: "How do you handle MongoDB security?" + answer: "We implement security at every layer. Network level: VPC peering, IP access lists, and private endpoints for Atlas clusters. Authentication: SCRAM-SHA-256 or x.509 certificates with database-level role-based access control. Encryption: TLS for data in transit and encryption at rest enabled by default on Atlas. Application level: input validation, parameterized queries to prevent injection, and field-level encryption for sensitive data. Audit logging enabled for compliance requirements." + - question: "What version of MongoDB should I use?" + answer: "MongoDB 8.0 for all new projects. It includes queryable encryption, improved aggregation performance, and better time-series collection support. For existing applications, we help teams upgrade incrementally from older versions, addressing deprecated features and driver compatibility along the way. MongoDB 7.0 and 6.0 are still supported but reaching end-of-life. If you are on MongoDB 4.x or earlier, upgrading should be a priority for security and performance reasons." +philosophy: + title: "Our Approach to MongoDB Development" + subtitle: "Document databases reward different thinking. We design for it." + blocks: + - title: "Query-Driven Schema Design" + description: "Relational thinking produces bad MongoDB schemas. We design documents around how your application reads and writes data, not how entities relate on a whiteboard. The schema serves the queries, not the other way around." + - title: "MongoDB Indexing Is Architecture" + description: "Indexes are not an afterthought. We plan indexing strategy during schema design because the two are inseparable. A well-indexed collection with the right schema serves queries in under a millisecond. A poorly indexed one scans millions of documents." + - title: "Right-Sized Documents" + description: "Not everything belongs in one document. We balance embedding for read performance against referencing for write efficiency. Documents that grow without bound (unbounded arrays, unlimited nested objects) cause performance degradation. We design schemas with growth patterns in mind." + - title: "MongoDB Operational Simplicity" + description: "Sharding adds complexity. Replica set topologies add complexity. We start with the simplest architecture that meets your requirements and add complexity only when data volume or traffic demands it. Most applications under 500 GB perform well on a properly indexed single replica set." + - title: "Exit-Ready Data Architecture" + description: "Every MongoDB system we design can be maintained by your team or a different vendor. Documented schema decisions, migration scripts, and operational runbooks. You own everything, always." +cta: + title: "Ready to Discuss Your MongoDB Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a Database Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "MongoDB Development Services | NoSQL Database Engineering" + description: "MongoDB development services for schema design, performance optimization, and Atlas management. Senior engineers, honest guidance. Talk to the team." +--- diff --git a/content/technologies/postgresql.mdx b/content/technologies/postgresql.mdx new file mode 100644 index 0000000..5a86a2c --- /dev/null +++ b/content/technologies/postgresql.mdx @@ -0,0 +1,114 @@ +--- +title: "PostgreSQL Development Services" +headline: "PostgreSQL Development Services" +headlineAccent: "Database Design, Optimization & Cloud Infrastructure" +description: "PostgreSQL databases designed, optimized, and operated by senior engineers who've built data systems for Setu, Pine Labs, and KredX." +capabilities: + - title: "PostgreSQL Schema Design & Data Modeling" + description: "PostgreSQL schema design that survives your next ten features, not just the current sprint. Normalized tables where consistency matters, denormalized views where read performance matters. Proper use of PostgreSQL-specific types: JSONB for flexible data, arrays for tags, range types for scheduling, and composite types for structured fields. We design schemas that make your queries simple and your migrations painless." + icon: "layers" + - title: "PostgreSQL Performance Optimization" + description: "Slow PostgreSQL queries diagnosed and fixed. We use EXPLAIN ANALYZE, pg_stat_statements, and auto_explain to find exactly where time is spent. Index strategy designed around your actual query patterns, not textbook rules. Partitioning for tables with millions of rows. Connection pooling with pgBouncer configured for your concurrency profile. We have taken query response times from 12 seconds to under 50 milliseconds on production systems." + icon: "bolt" + - title: "PostgreSQL Migration Services" + description: "Migrating from Oracle, SQL Server, MySQL, or MongoDB to PostgreSQL. Schema translation, stored procedure conversion, data migration with validation, and application-layer query rewrites. We run source and target databases in parallel during cutover so rollback is always an option. Zero-downtime migrations using logical replication for systems that cannot afford maintenance windows." + icon: "workflow" + - title: "PostgreSQL on Cloud (RDS, Aurora, Cloud SQL)" + description: "PostgreSQL deployed and configured on AWS RDS, Aurora PostgreSQL, or Google Cloud SQL. Instance sizing based on workload analysis, not guesswork. Automated backups, point-in-time recovery, read replicas for scaling reads, and parameter group tuning for your specific access patterns. We configure the managed service so you get the reliability without the operational overhead." + icon: "globe" + - title: "PostgreSQL High Availability & Replication" + description: "Streaming replication, logical replication, and failover configuration for systems that need 99.99% uptime. Hot standby replicas for read scaling, synchronous replication for zero data loss, and automated failover with Patroni or cloud-native solutions. We design the replication topology around your RPO and RTO requirements, not a one-size-fits-all template." + icon: "chart" + - title: "PostgreSQL Data Pipelines & ETL" + description: "PostgreSQL as the source or destination in your data pipeline. Change data capture with Debezium, real-time sync to Elasticsearch or data warehouses, and ETL/ELT pipelines feeding analytics. pgvector for AI embedding storage and similarity search, enabling vector queries alongside your relational data without a separate vector database." + icon: "document" +technologies: + - PostgreSQL 17 + - pgvector + - PostGIS + - TimescaleDB + - pgBouncer + - AWS RDS + - Aurora PostgreSQL + - Prisma + - TypeORM + - Drizzle + - pg-promise + - Debezium +relatedExpertise: + - nodejs + - python + - typescript + - golang + - java + - dotnet +process: + - number: 1 + title: "Data Architecture and Discovery (1-2 weeks)" + description: "We analyze your data requirements, access patterns, and growth projections. You get a technical proposal covering schema design, indexing strategy, hosting recommendation (self-managed vs. RDS vs. Aurora), replication topology, and backup policy. No implementation until the data model is right." + - number: 2 + title: "Schema Design and Migration Planning (1-2 weeks)" + description: "Entity-relationship diagrams, table definitions with constraints, index strategy documented, and migration scripts written. For database migrations, we map source-to-target schema differences and build the data validation suite. Your development team can start building against the schema immediately." + - number: 3 + title: "PostgreSQL Implementation & Optimization (4-12 weeks)" + description: "Database provisioned, schemas deployed, application integration built. Performance testing with production-like data volumes from the start. Query optimization happens during development, not after launch. We benchmark every critical query path against your SLA targets." + - number: 4 + title: "Load Testing and Hardening (1-2 weeks)" + description: "Simulated production load with realistic data volumes and concurrency. Connection pool sizing verified. Vacuum and autovacuum tuned. Monitoring configured with pg_stat_statements, CloudWatch or Datadog. Nothing goes live until the database handles your peak load with headroom." + - number: 5 + title: "Handoff & PostgreSQL Operations Transfer" + description: "Complete documentation covering schema decisions, index rationale, replication setup, and operational runbooks. Your team or DBA owns the database entirely. Optional support retainer for ongoing optimization, but no lock-in." +engagementModels: + title: "Hire PostgreSQL Developers" + subtitle: "Senior database engineers who design schemas that scale from day one." + models: + - title: "Dedicated Developer" + description: "Engineers with 5+ years of production PostgreSQL experience spanning schema design, query optimization, replication, and cloud deployment. Not application developers who write SQL on the side." + bestFor: "Ongoing database work or optimization projects, 3-month minimum engagement" + - title: "Team Pod (2-3 Engineers + Lead)" + description: "A team covering database architecture, application integration, and DevOps. Full ownership of data layer design, implementation, migration, and production operations." + bestFor: "Large-scale migrations or data platform builds, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed-scope engagement for specific database projects: migrations, performance audits, or schema redesigns. Clear deliverables, timeline, and transparent pricing." + bestFor: "Defined scope like a migration or performance overhaul, scope-dependent" +faqs: + - question: "How much do PostgreSQL development services cost?" + answer: "PostgreSQL development costs vary by scope. A performance audit and optimization for an existing database typically runs $8,000 to $25,000. A greenfield database design with application integration costs $30,000 to $80,000. A full database migration from Oracle or SQL Server to PostgreSQL ranges from $50,000 to $200,000+ depending on schema complexity, stored procedure conversion, and data volume. Procedure offers a free architecture consultation to scope your project." + - question: "PostgreSQL vs MySQL - which should I choose?" + answer: "PostgreSQL supports advanced data types (JSONB, arrays, ranges, custom types), full ACID compliance, and sophisticated query planning. MySQL is simpler to set up and performs well for read-heavy web applications with straightforward schemas. For applications requiring complex queries, geospatial data (PostGIS), full-text search, or AI vector operations (pgvector), PostgreSQL is the stronger choice. For simple CRUD applications where operational simplicity is the priority, MySQL works well. Procedure builds with both and recommends based on your actual requirements." + - question: "When should I use PostgreSQL?" + answer: "PostgreSQL is the right choice when your application needs complex queries with joins across many tables, JSONB for semi-structured data alongside relational data, geospatial queries (PostGIS), time-series data (TimescaleDB), vector similarity search for AI applications (pgvector), or strict data integrity with advanced constraints. It is also the best open-source option for teams migrating away from Oracle or SQL Server. PostgreSQL handles workloads from small applications to multi-terabyte databases with billions of rows." + - question: "How do you handle PostgreSQL scaling?" + answer: "PostgreSQL scales through multiple strategies. Vertical scaling with larger instances handles most applications up to the mid-millions of rows. Read replicas distribute query load for read-heavy workloads. Table partitioning manages tables with hundreds of millions of rows. Connection pooling with pgBouncer supports thousands of concurrent application connections. For write-heavy workloads at extreme scale, Citus (distributed PostgreSQL) shards data across multiple nodes. Procedure selects the scaling strategy based on your actual data volume and access patterns." + - question: "Can you migrate our database from Oracle or SQL Server to PostgreSQL?" + answer: "Yes. Procedure has migrated production databases from Oracle, SQL Server, and MySQL to PostgreSQL. The process includes schema translation (data types, constraints, indexes), stored procedure and function conversion, data migration with row-level validation, and application query rewrites. We use logical replication to run both databases in parallel during cutover, so rollback is always available. Typical migrations for mid-size databases (50-500GB) take 8-16 weeks." + - question: "Is PostgreSQL secure enough for enterprise use?" + answer: "PostgreSQL has a strong security track record with over 25 years of active development. It supports row-level security policies, column-level encryption, SSL/TLS for connections, and role-based access control with fine-grained permissions. On AWS RDS and Aurora, encryption at rest is enabled by default. Procedure configures security following CIS benchmarks: least-privilege roles, audit logging, connection restrictions, and automated vulnerability scanning." + - question: "What version of PostgreSQL do you use?" + answer: "Procedure uses PostgreSQL 17 (latest stable) for all new projects. Key improvements include incremental backup support, improved JSON query syntax (JSON_TABLE), faster vacuum operations, and enhanced logical replication with failover capabilities. For existing databases, we help teams upgrade from older PostgreSQL versions with thorough testing and minimal downtime using pg_upgrade or logical replication." + - question: "Can PostgreSQL handle AI and vector workloads?" + answer: "Yes. pgvector extends PostgreSQL with vector data types and similarity search operators (cosine distance, inner product, L2 distance). This means you can store AI embeddings alongside your relational data and query both in a single SQL statement. For many applications, pgvector eliminates the need for a separate vector database like Pinecone or Weaviate. Procedure has implemented pgvector for semantic search, recommendation engines, and RAG (retrieval-augmented generation) systems." +philosophy: + title: "Our Approach to PostgreSQL Development" + subtitle: "Your database outlives your application code. We design it that way." + blocks: + - title: "Schema Design Is System Design" + description: "The database schema is the most durable part of your system. Application code gets rewritten, but table structures persist for years. We invest time in getting the data model right because fixing a schema mistake in production costs 10x more than getting it right upfront." + - title: "Measure Before Optimizing PostgreSQL" + description: "We do not add indexes based on intuition. EXPLAIN ANALYZE, pg_stat_statements, and workload analysis tell us exactly where time is spent. Every optimization is measurable, and we show you the before and after numbers." + - title: "Managed Services When Possible" + description: "Running PostgreSQL on bare metal is rarely worth the operational cost. AWS RDS or Aurora handles backups, patching, failover, and monitoring. We configure the managed service correctly so your team focuses on application logic, not database operations." + - title: "Data Integrity Over Convenience" + description: "Foreign keys, check constraints, unique indexes, and NOT NULL where appropriate. The database should reject bad data, not leave validation to the application layer alone. Constraints are documentation that the database enforces automatically." + - title: "Exit-Ready Data Architecture" + description: "No proprietary extensions, no vendor lock-in patterns, no undocumented schema decisions. Your team or any qualified DBA can take over operations. Complete documentation covering every schema choice and its rationale." +cta: + title: "Ready to Discuss Your PostgreSQL Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a Database Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "PostgreSQL Development Services | Design & Optimization" + description: "PostgreSQL development services for schema design, performance optimization, cloud deployment, and migrations. Senior database engineers. Talk to the team." +--- diff --git a/content/technologies/swift.mdx b/content/technologies/swift.mdx new file mode 100644 index 0000000..6fb1400 --- /dev/null +++ b/content/technologies/swift.mdx @@ -0,0 +1,121 @@ +--- +title: "Swift Development Services" +headline: "Swift Development Services" +headlineAccent: "Native iOS & Apple Platform Apps" +description: "Native iOS, watchOS, and tvOS applications built by senior engineers who understand Apple's platform deeply, not just its syntax." +capabilities: + - title: "Native iOS Development with Swift" + description: "Production iOS applications built with Swift 6, SwiftUI, and modern Apple frameworks. MVVM architecture, async/await concurrency, and accessibility built in from the start. Apps that pass App Store review on the first submission and perform well on both current and older iPhones." + icon: "globe" + - title: "SwiftUI & UIKit Development" + description: "SwiftUI for new features and screens. UIKit when you need fine-grained control or are working within an existing codebase. We know when each is the right choice and how to combine them in the same project. SwiftUI's declarative model speeds development by 30-40% for standard UI patterns." + icon: "layers" + - title: "Swift watchOS & tvOS Apps" + description: "Swift companion apps for Apple Watch and Apple TV that extend your iOS app's value. WatchKit and SwiftUI for watchOS, TVUIKit and focus-based navigation for tvOS. Shared business logic with your iOS app through Swift packages to avoid duplicating code across platforms." + icon: "bolt" + - title: "iOS App Modernization (Objective-C to Swift)" + description: "Migrate Objective-C codebases to Swift incrementally. Refactor UIKit apps to SwiftUI. Update architectures from MVC to MVVM with Combine or async/await. Swift and Objective-C interoperate fully, so migration happens screen by screen without breaking the build. Most modernization projects complete in 3-6 months." + icon: "workflow" + - title: "Swift Backend (Vapor)" + description: "Server-side Swift using Vapor for teams that want a unified language across iOS and backend. REST APIs, WebSocket services, and database integrations. Best suited for teams where iOS engineers also own backend services and want to share models and validation logic between client and server." + icon: "chart" + - title: "Swift App Clips & WidgetKit Development" + description: "App Clips for lightweight, instant experiences without a full install. WidgetKit for home screen and Lock Screen widgets that keep your app present in users' daily routine. Live Activities for real-time updates on the Lock Screen and Dynamic Island. These features increase engagement without requiring users to open the full app." + icon: "document" +technologies: + - Swift 6 + - SwiftUI + - UIKit + - Combine + - Swift Concurrency + - Core Data + - SwiftData + - CloudKit + - Vapor + - Xcode 16 + - TestFlight + - XCTest + - Swift Testing + - WidgetKit + - App Intents + - StoreKit 2 + - Push Notifications (APNs) + - Core ML + - SPM +relatedExpertise: + - react-native + - flutter + - kotlin + - java + - nodejs + - typescript +process: + - number: 1 + title: "Discovery & Architecture (1-2 weeks)" + description: "Define screens, user flows, and technical approach. Choose between SwiftUI-first or UIKit-based architecture. If you have an existing app, we audit the codebase and identify modernization priorities. Deliverable: technical spec, architecture diagram, and Figma wireframes." + - number: 2 + title: "Design System & Component Library (1-2 weeks)" + description: "Build a custom SwiftUI component library that implements your brand's design language. SF Symbols integration, Dynamic Type support, and dark mode from the start. Components tested in isolation with SwiftUI Previews and snapshot tests." + - number: 3 + title: "Swift Development & Iteration (6-16 weeks)" + description: "Sprint-based Swift development with TestFlight builds for real-device testing throughout. Weekly demos. SwiftUI Previews and hot reload keep feedback loops tight. Internal builds distributed via TestFlight to stakeholders for continuous validation." + - number: 4 + title: "QA, Performance & Launch (1-2 weeks)" + description: "Testing across iPhone, iPad, and target Apple platforms. UI tests, performance profiling with Instruments (Time Profiler, Memory Graph), and accessibility audits. App Store submission with optimized metadata, screenshots, and App Store Connect configuration." + - number: 5 + title: "Post-Launch & Swift App Maintenance" + description: "Bug fixes, iOS/watchOS compatibility updates, feature development, and App Store policy compliance. Ongoing monitoring with crash analytics. App Store review management for updates." +engagementModels: + title: "Hire Swift Developers" + subtitle: "Senior iOS engineers with deep Apple platform expertise and production experience." + models: + - title: "Dedicated Developer" + description: "Full-time on your project, integrated into your team. Engineers proficient in Swift 6, SwiftUI, UIKit, and modern Apple platform APIs. Deep understanding of App Store guidelines and review processes." + bestFor: "Ongoing iOS development, 3-month minimum engagement" + - title: "Team Pod (2-4 Engineers + Lead)" + description: "iOS + backend + QA for a complete mobile team. Architecture, implementation, testing, and App Store deployment covered." + bestFor: "Full product ownership, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed scope, milestone-based delivery. Defined specs, agreed milestones, and transparent pricing." + bestFor: "Defined scope with clear deliverables, scope-dependent" +faqs: + - question: "How much does iOS app development with Swift cost?" + answer: "Swift iOS app development costs vary by complexity. Simple apps with standard UI run $15,000 to $40,000. Mid-complexity apps (e-commerce, social, data-heavy) range from $40,000 to $120,000. Enterprise iOS apps with offline support, SSO, compliance features, and Apple Watch companion apps run $120,000 to $350,000+. Dedicated Swift developer hiring starts at $3,500/month. Final cost depends on features, integrations, and Apple platform targets." + - question: "Swift vs React Native for iOS app development?" + answer: "Swift produces genuinely native iOS apps with full access to every Apple API, best-in-class performance, and day-one support for new iOS features. React Native trades some of that for cross-platform reach, shipping to both iOS and Android from one JavaScript codebase. Choose Swift when your app targets only Apple platforms, needs deep hardware integration (HealthKit, ARKit, CarPlay), or when performance and native feel are non-negotiable. Choose React Native when you need both iOS and Android and can accept minor platform compromises." + - question: "SwiftUI vs UIKit for new iOS projects?" + answer: "SwiftUI is the right default for most new iOS projects in 2026. It offers faster development (30-40% less code than UIKit for standard UI), built-in accessibility, dark mode, and Dynamic Type support, plus native integration with Apple's latest frameworks. UIKit is still the better choice when you need pixel-perfect control over animations, complex collection view layouts, or when integrating with large existing UIKit codebases. Many production apps use both: SwiftUI for new screens and UIKit where fine-grained control is needed." + - question: "How long does it take to build an iOS app?" + answer: "MVP/simple apps: 8-12 weeks. Mid-complexity apps: 12-20 weeks. Enterprise apps with multiple Apple platform targets: 16-28 weeks. These timelines include design, development, testing, and App Store submission. SwiftUI's declarative approach and Previews accelerate development compared to traditional UIKit. Add 2-4 weeks if the project includes watchOS or widget development." + - question: "What does Swift 6 strict concurrency mean for my app?" + answer: "Swift 6 enables strict concurrency checking by default, catching data races at compile time rather than in production crashes. This means your app's concurrent code (networking, background processing, UI updates) is verified safe before it ships. For existing apps, migration to strict concurrency can be done incrementally, module by module. The result is fewer crashes, fewer threading bugs, and more predictable behavior under load. It is the most significant Swift language change since async/await in Swift 5.5." + - question: "What is the App Store review process and how do you handle it?" + answer: "App Store review typically takes 24-48 hours for new submissions. Apple reviews for functionality, design quality, privacy compliance, and guideline adherence. Common rejection reasons include incomplete functionality, privacy description mismatches, and in-app purchase policy violations. We handle all of these proactively: privacy manifests configured correctly, App Tracking Transparency implemented where needed, and StoreKit 2 for subscriptions. Our apps pass review on the first submission in the vast majority of cases." + - question: "What does ongoing iOS app maintenance involve?" + answer: "iOS apps require regular maintenance for iOS version compatibility (Apple releases a new major version annually), SDK deprecations, App Store policy changes, and security updates. Typical maintenance includes updating to new iOS APIs, fixing issues on new iPhone hardware, maintaining App Store listing compliance, and monitoring crash rates via Xcode Organizer. Budget 15-20% of initial development cost annually for maintenance. Neglected apps eventually break or get removed from the App Store." + - question: "Should we build native iOS or go cross-platform?" + answer: "Build native Swift when you target only Apple platforms, need deep integration with Apple ecosystem features (HealthKit, ARKit, Siri Shortcuts, CarPlay, Apple Watch), or when your users expect a premium iOS experience. Go cross-platform (React Native or Flutter) when you need both iOS and Android and budget does not support two separate native teams. Cross-platform frameworks have matured significantly, but native Swift still provides the best performance, smallest app size, and earliest access to new Apple features." +philosophy: + title: "Our Approach to Swift Development" + subtitle: "We build iOS apps that leverage the Apple ecosystem, not fight against it." + blocks: + - title: "Platform-Native, Not Platform-Agnostic" + description: "Apple designs its platforms as integrated systems. We build apps that take advantage of that: Handoff between iPhone and Mac, Siri Shortcuts for voice access, WidgetKit for home screen presence, and SharePlay for collaborative features. These integrations turn a good app into one users rely on daily." + - title: "SwiftUI Where It Fits" + description: "SwiftUI is the future of Apple UI development. We adopt it aggressively for new projects and new screens in existing apps. But we are pragmatic: some patterns still work better in UIKit, and forcing SwiftUI into every corner creates worse outcomes. We choose the right tool per screen." + - title: "Swift Concurrency Done Right" + description: "Swift 6's strict concurrency model eliminates entire categories of bugs. We adopt actors, sendable types, and structured concurrency from day one. The code compiles with strict concurrency checking enabled, not just in permissive mode. This catches threading issues at build time instead of 3 AM production crashes." + - title: "Swift Accessibility as Default" + description: "VoiceOver, Dynamic Type, and high-contrast support are not afterthoughts. SwiftUI makes many accessibility features automatic, but proper implementation still requires intentional design: meaningful labels, logical navigation order, and appropriate semantic groupings." + - title: "Swift Projects Built for Your Team to Own" + description: "Every iOS project ships with clean architecture, documented decisions, CI/CD pipelines (Xcode Cloud or GitHub Actions), and fastlane scripts. Your team takes full ownership. No proprietary tools, no hidden dependencies, no lock-in." +cta: + title: "Ready to Discuss Your Swift Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a Swift Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "Swift Development Services | iOS & Apple Platform Apps" + description: "Native iOS app development with Swift 6 and SwiftUI. Senior engineers for iPhone, iPad, Apple Watch, and Apple TV apps. Talk to the team." +--- diff --git a/content/technologies/typescript.mdx b/content/technologies/typescript.mdx new file mode 100644 index 0000000..43ad627 --- /dev/null +++ b/content/technologies/typescript.mdx @@ -0,0 +1,114 @@ +--- +title: "TypeScript Development Services" +headline: "TypeScript Development Services" +headlineAccent: "Type-Safe Web, API & Full-Stack Engineering" +description: "TypeScript applications, migrations, and full-stack systems built by the team behind procedure.tech, Setu, KredX, and Last9." +capabilities: + - title: "TypeScript Migration" + description: "Moving JavaScript codebases to TypeScript, incrementally. We start with strict: false, add types to critical paths first, then tighten the compiler until the codebase is fully strict. Your app stays live throughout. No productivity freeze, no big-bang rewrite. We have migrated codebases with 200K+ lines of JavaScript to strict TypeScript without a single day of downtime." + icon: "workflow" + - title: "Enterprise TypeScript Applications" + description: "Large-scale TypeScript applications with NestJS, React 19, and Next.js 16. Monorepos with Turborepo, shared type packages, and strict compiler settings across every workspace. The type system becomes your documentation and your safety net. Runtime errors caught at build time, not by your users." + icon: "globe" + - title: "Type-Safe APIs with tRPC, Prisma & Zod" + description: "End-to-end type safety from database to UI. Prisma generates types from your schema, tRPC or GraphQL Codegen carries them through your API layer, and Zod validates runtime inputs at every boundary. A change to your database schema surfaces type errors in your React components instantly. No more silent contract mismatches between frontend and backend." + icon: "layers" + - title: "Full-Stack TypeScript (React, NestJS, Prisma)" + description: "One language across your entire stack. React 19 or Next.js 16 on the frontend, NestJS or Fastify on the backend, Prisma or Drizzle for data access, all in TypeScript. Your team shares types, utilities, and domain logic across every layer. Fewer context switches, faster debugging, simpler hiring." + icon: "chart" + - title: "Library and SDK Development" + description: "TypeScript libraries and SDKs with proper declaration files, generics, and discriminated unions. Published to npm with semantic versioning, automated changelogs, and dual ESM/CJS output. We build packages that feel native to TypeScript, not JavaScript wrappers with .d.ts files bolted on." + icon: "document" + - title: "TypeScript Tooling & Code Quality" + description: "ESLint with typescript-eslint, Vitest for unit and integration tests, Playwright for end-to-end coverage. Strict compiler options enforced via CI. We configure tsconfig.json properly once so your team never debates compiler settings again. Every PR gets type-checked, linted, and tested before merge." + icon: "bolt" +technologies: + - TypeScript 5.7 + - React 19 + - Next.js 16 + - Node.js 22 + - NestJS + - Prisma + - Zod + - tRPC + - Vitest + - ESLint + - Playwright + - Turborepo +relatedExpertise: + - react + - nextjs + - nodejs + - postgresql + - mongodb + - angular +process: + - number: 1 + title: "Codebase Audit and Architecture (1-2 weeks)" + description: "We assess your existing codebase, identify type coverage gaps, and define the migration or build strategy. You get a technical proposal covering compiler configuration, module boundaries, shared type packages, and CI/CD integration. For greenfield projects, we establish the TypeScript architecture before writing application code." + - number: 2 + title: "Type Foundation and Tooling (1-2 weeks)" + description: "tsconfig.json configured for your project's needs. ESLint rules set. Shared type packages created if using a monorepo. For migrations, we establish the incremental adoption path and convert critical modules first. For new builds, the type system and toolchain are locked before feature development begins." + - number: 3 + title: "TypeScript Development & Iteration (6-16 weeks)" + description: "Sprint-based TypeScript development with strict type checking on every pull request. Your team sees working features shipped continuously. For migrations, we convert module by module while the application stays live. Type coverage tracked and reported weekly." + - number: 4 + title: "Validation and Hardening (1-2 weeks)" + description: "Full TypeScript strict mode enabled and verified. No any types in production code. Vitest and Playwright test suites passing. Bundle analysis completed to confirm TypeScript compilation produces optimized output. Performance benchmarks met." + - number: 5 + title: "Handoff & TypeScript Team Enablement" + description: "Complete documentation covering TypeScript conventions, compiler configuration decisions, and type architecture. Your team owns the codebase and can extend it without us. Optional support retainer available, but no lock-in." +engagementModels: + title: "Hire TypeScript Developers" + subtitle: "Senior TypeScript engineers who ship type-safe code from week one." + models: + - title: "Dedicated Developer" + description: "Engineers with 4+ years of production TypeScript experience across React, Node.js, and full-stack applications. Deep understanding of generics, conditional types, and compiler internals. Not developers who learned TypeScript last month." + bestFor: "Ongoing development or migration work, 3-month minimum engagement" + - title: "Team Pod (2-4 Engineers + Lead)" + description: "A self-contained team that owns full feature delivery in TypeScript. Architecture, implementation, testing, and deployment covered. Mixed team of leads and senior engineers staffed based on project needs." + bestFor: "Full application builds or large-scale migrations, 6-month minimum engagement" + - title: "Project-Based Delivery" + description: "Fixed-scope engagement with clear deliverables, timeline, and budget. Defined type contracts, agreed milestones, and transparent pricing." + bestFor: "Defined scope with clear deliverables, scope-dependent" +faqs: + - question: "How much does TypeScript development cost?" + answer: "TypeScript development costs depend on project scope. A JavaScript-to-TypeScript migration for a medium codebase (50K-100K lines) typically runs $20,000 to $60,000. A full-stack TypeScript application with 15-25 screens costs $40,000 to $120,000. Enterprise platforms with monorepo architecture, shared type packages, and multiple teams can run $120,000 to $350,000+. Procedure offers a free architecture consultation to scope your specific project." + - question: "TypeScript vs JavaScript - which should I use?" + answer: "TypeScript is JavaScript with a type system. For any project with more than one developer or expected to live longer than six months, TypeScript pays for itself. The compiler catches bugs that would otherwise reach production, refactoring becomes safe instead of risky, and IDE support (autocomplete, go-to-definition, inline errors) dramatically improves developer velocity. The initial setup cost is small compared to the debugging time TypeScript eliminates over a project's lifetime." + - question: "How long does a TypeScript migration take?" + answer: "A TypeScript migration timeline depends on codebase size and test coverage. A 20K-line JavaScript project with good tests can be fully migrated in 4-6 weeks. A 100K-line codebase takes 8-16 weeks. Enterprise codebases with 500K+ lines are typically 3-6 months with incremental adoption. Procedure migrates incrementally, starting with strict: false and tightening the compiler as coverage expands. The application stays live throughout the entire process." + - question: "Should I use strict mode in TypeScript?" + answer: "Yes. Strict mode enables strictNullChecks, noImplicitAny, and other compiler flags that catch the most common runtime errors at build time. Every new TypeScript project should start with strict: true. For existing projects, Procedure enables strict mode incrementally, module by module, so your team is not blocked by thousands of new errors on day one." + - question: "Is TypeScript good for backend development?" + answer: "TypeScript is excellent for backend development. NestJS provides enterprise-grade patterns (dependency injection, decorators, modules) with full TypeScript support. Fastify offers the highest throughput for HTTP services. Prisma and Drizzle generate typed database clients from your schema. The same type definitions can be shared between frontend and backend, eliminating an entire class of integration bugs. Companies like Stripe, Shopify, and Airbnb run backend services in TypeScript." + - question: "Can you train our team on TypeScript?" + answer: "Yes. Procedure provides TypeScript training as part of migration engagements. This includes hands-on workshops covering generics, utility types, discriminated unions, and advanced patterns. Training is tailored to your codebase, not generic exercises. Your team works with the types and patterns they will actually use in production." + - question: "What version of TypeScript do you use?" + answer: "Procedure uses TypeScript 5.7 (latest stable) for all new projects. Key features include using declarations for explicit resource management, improved control flow narrowing, and faster type checking. For existing projects, we help teams upgrade from older TypeScript versions and adopt new features incrementally." + - question: "Do you work with US-based teams from India?" + answer: "Yes. Procedure's engineering team is based in Mumbai with working hours overlapping US EST and PST. The team has delivered TypeScript projects for US clients across fintech, SaaS, and enterprise platforms. Communication happens over Slack, daily standups, and weekly demos. Same tools, same cadence, different timezone." +philosophy: + title: "Our Approach to TypeScript Development" + subtitle: "Types are architecture decisions, not annotations you add later." + blocks: + - title: "Strict From Day One" + description: "Every new TypeScript project starts with strict: true. No any types in production code. The compiler is your first line of defense against runtime errors, and we configure it to catch everything it can." + - title: "Types as Documentation" + description: "Well-designed TypeScript types communicate intent better than comments. When a function accepts a discriminated union instead of a string, the type system tells every developer what values are valid without reading a wiki page." + - title: "End-to-End Type Safety" + description: "Types that stop at the API boundary are half the value. We use Prisma, tRPC, and Zod to carry type safety from the database through the API to the UI. A schema change surfaces errors everywhere it matters, instantly." + - title: "Incremental Adoption Over Perfection" + description: "For migrations, we prioritize progress over perfection. Start with loose types on legacy code, strict types on new code, and tighten gradually. Your team ships features while the migration happens in the background." + - title: "TypeScript Tooling That Enforces Standards" + description: "We do not rely on code review to catch type issues. CI pipelines run the TypeScript compiler, ESLint with typescript-eslint, and test suites on every pull request. Standards are automated, not aspirational." +cta: + title: "Ready to Discuss Your TypeScript Project?" + description: "Talk directly with engineers, not sales. We will assess fit and give honest next steps." + buttonText: "Talk to a TypeScript Engineer" + buttonLink: "/contact-us" + supportingNote: "No obligation. No pressure. Clear technical direction." +seo: + title: "TypeScript Development Services | Type-Safe Engineering" + description: "TypeScript development services for migrations, full-stack apps, and enterprise platforms. Strict mode, end-to-end type safety. Talk to senior engineers." +--- diff --git a/lib/technologies-hub-data.ts b/lib/technologies-hub-data.ts index d25218a..4d30de5 100644 --- a/lib/technologies-hub-data.ts +++ b/lib/technologies-hub-data.ts @@ -9,8 +9,7 @@ export type CategoryId = | "databases" | "ai-ml" | "messaging" - | "data-api" - | "testing"; + | "data-api"; export interface CategoryLink { label: string; @@ -89,14 +88,6 @@ export const categories: Category[] = [ }, { id: "messaging", label: "Messaging & Events", hash: "messaging" }, { id: "data-api", label: "Data & API", hash: "data-api" }, - { - id: "testing", - label: "Quality Assurance & Testing", - hash: "testing", - serviceLinks: [ - { label: "Software Testing & QA Services", href: "/services/software-testing-and-qa" }, - ], - }, ]; export const technologies: TechnologyItem[] = [ @@ -131,7 +122,7 @@ export const technologies: TechnologyItem[] = [ category: "frontend", description: "Typed superset of JavaScript for large-scale applications", logoPath: "/technologies/typescript-logo.svg", - href: null, + href: "/technologies/typescript", }, // Backend & Server-Side @@ -165,7 +156,7 @@ export const technologies: TechnologyItem[] = [ category: "backend", description: "Battle-tested platform for enterprise and distributed systems", logoPath: "/technologies/java-logo.svg", - href: null, + href: "/technologies/java", }, { name: "Go", @@ -173,7 +164,7 @@ export const technologies: TechnologyItem[] = [ category: "backend", description: "High-performance compiled language for cloud-native services", logoPath: "/technologies/golang-logo.svg", - href: null, + href: "/technologies/golang", }, { name: "Rust", @@ -207,7 +198,7 @@ export const technologies: TechnologyItem[] = [ category: "mobile", description: "Native iOS and macOS application development", logoPath: "/technologies/swift-logo.svg", - href: null, + href: "/technologies/swift", }, { name: "Kotlin", @@ -215,7 +206,7 @@ export const technologies: TechnologyItem[] = [ category: "mobile", description: "Modern language for native Android development", logoPath: "/technologies/kotlin-logo.svg", - href: null, + href: "/technologies/kotlin", }, // Cloud Platforms @@ -225,7 +216,7 @@ export const technologies: TechnologyItem[] = [ category: "cloud", description: "Comprehensive cloud platform for compute, storage, and AI services", logoPath: "/technologies/aws-logo.svg", - href: null, + href: "/technologies/aws", }, { name: "Microsoft Azure", @@ -301,7 +292,7 @@ export const technologies: TechnologyItem[] = [ category: "databases", description: "Advanced open-source relational database for complex workloads", logoPath: "/technologies/postgresql-logo.svg", - href: null, + href: "/technologies/postgresql", }, { name: "MongoDB", @@ -309,7 +300,7 @@ export const technologies: TechnologyItem[] = [ category: "databases", description: "Document database for flexible, schema-less data models", logoPath: "/technologies/mongodb-logo.svg", - href: null, + href: "/technologies/mongodb", }, { name: "Redis", @@ -373,14 +364,6 @@ export const technologies: TechnologyItem[] = [ }, // Data & API - { - name: "Data Engineering", - slug: "data-engineering", - category: "data-api", - description: "ETL pipelines, data lakes, and real-time processing architectures", - logoPath: "/technologies/data-engineering-logo.svg", - href: null, - }, { name: "GraphQL", slug: "graphql", @@ -389,24 +372,6 @@ export const technologies: TechnologyItem[] = [ logoPath: "/technologies/graphql-logo.svg", href: null, }, - { - name: "Serverless", - slug: "serverless", - category: "data-api", - description: "Event-driven compute without infrastructure management", - logoPath: "/technologies/serverless-logo.svg", - href: null, - }, - - // Testing - { - name: "Test Automation", - slug: "test-automation", - category: "testing", - description: "End-to-end, integration, and unit testing frameworks and strategy", - logoPath: "/technologies/test-automation-logo.svg", - href: null, - }, ]; export function getTechnologiesByCategory( diff --git a/public/assets/technologies/aws-development.png b/public/assets/technologies/aws-development.png new file mode 100644 index 0000000..70c9cea Binary files /dev/null and b/public/assets/technologies/aws-development.png differ diff --git a/public/assets/technologies/golang-development.png b/public/assets/technologies/golang-development.png new file mode 100644 index 0000000..807f62d Binary files /dev/null and b/public/assets/technologies/golang-development.png differ diff --git a/public/assets/technologies/java-development.png b/public/assets/technologies/java-development.png new file mode 100644 index 0000000..f45b8e1 Binary files /dev/null and b/public/assets/technologies/java-development.png differ diff --git a/public/assets/technologies/kotlin-development.png b/public/assets/technologies/kotlin-development.png new file mode 100644 index 0000000..97b12e9 Binary files /dev/null and b/public/assets/technologies/kotlin-development.png differ diff --git a/public/assets/technologies/mongodb-development.png b/public/assets/technologies/mongodb-development.png new file mode 100644 index 0000000..2bc7cf8 Binary files /dev/null and b/public/assets/technologies/mongodb-development.png differ diff --git a/public/assets/technologies/postgresql-development.png b/public/assets/technologies/postgresql-development.png new file mode 100644 index 0000000..21a45d9 Binary files /dev/null and b/public/assets/technologies/postgresql-development.png differ diff --git a/public/assets/technologies/swift-development.png b/public/assets/technologies/swift-development.png new file mode 100644 index 0000000..30a2543 Binary files /dev/null and b/public/assets/technologies/swift-development.png differ diff --git a/public/assets/technologies/typescript-development.png b/public/assets/technologies/typescript-development.png new file mode 100644 index 0000000..5b347d2 Binary files /dev/null and b/public/assets/technologies/typescript-development.png differ diff --git a/scripts/generate-og-images.mjs b/scripts/generate-og-images.mjs index cee5def..ae435e7 100644 --- a/scripts/generate-og-images.mjs +++ b/scripts/generate-og-images.mjs @@ -48,6 +48,46 @@ const pages = [ line1: "React Native Development", line2: "Services", }, + { + file: "typescript-development.png", + line1: "TypeScript Development Services", + line2: "Type-Safe Web & API Engineering", + }, + { + file: "postgresql-development.png", + line1: "PostgreSQL Development Services", + line2: "Database Design & Optimization", + }, + { + file: "aws-development.png", + line1: "AWS Development Services", + line2: "Cloud-Native Apps & Infrastructure", + }, +{ + file: "golang-development.png", + line1: "Go Development Services", + line2: "Microservices & Cloud-Native APIs", + }, + { + file: "mongodb-development.png", + line1: "MongoDB Development Services", + line2: "NoSQL Database Engineering", + }, + { + file: "java-development.png", + line1: "Java Development Services", + line2: "Enterprise & Spring Boot Apps", + }, + { + file: "kotlin-development.png", + line1: "Kotlin Development Services", + line2: "Native Android & Multiplatform", + }, + { + file: "swift-development.png", + line1: "Swift Development Services", + line2: "Native iOS & Apple Platform Apps", + }, ]; function buildSvg({ line1, line2 }) { @@ -114,4 +154,4 @@ for (const page of pages) { console.log(`✓ ${page.file}`); } -console.log("\nDone — 7 images generated."); +console.log(`\nDone — ${pages.length} images generated.`);