Healthcare EHR System
Modular EHR architecture with service isolation, clinical workflows, and real-time sync.
Samuel Kifle — Software Engineer
Building scalable SaaS, fintech, identity, and enterprise systems with Go, Next.js, PostgreSQL, Ory IAM, and Cloudflare edge infrastructure.
Hello, I'm Software Engineer
Building scalable SaaS & Enterprise Systems
Based in Addis Ababa, Ethiopia.
Samuel Kifle is a Software Engineer specializing in Go, backend engineering, distributed systems, cloud architecture, Kubernetes, microservices, platform engineering, AI, and full-stack development. I build production-ready platforms with Next.js and Go — including ecosystems with Ory IAM, payment orchestration, and multi-channel notifications.
5
Companies shipped for
15+
Production systems
3+
Years building software
Samuel Kifle — Software engineer focused on resilient systems
I build products that scale and stay maintainable.
I specialize in Go, backend engineering, distributed systems, cloud architecture, Kubernetes, microservices, platform engineering, AI, and full-stack development for SaaS and enterprise platforms. My production experience spans healthcare, identity, fintech, and distributed systems — with Next.js, Go, Django, NestJS, PostgreSQL, and the Ory IAM ecosystem as the foundation behind Senappe, where I architect payment, notification, and identity services end to end.
I am particularly strong in architecture, service boundaries, data modeling, and system-level debugging. Beyond coding, I lead implementation planning, collaborate with product teams, and drive feature delivery from concept to production.
Role
Senior Software Engineer
Residence
Ethiopia
Availability
Open to full-time and contract roles on remote or relocation basis
Address
Addis Ababa, Ethiopia
Core
Capabilities
Backend & API Architecture
Full-Stack Product Development
Systems Design & Microservices
AI Integration & Automation
DevOps, CI/CD & Reliability
What I Build
SaaS PlatformsPayment & Fintech SystemsIdentity & Access ManagementHealthcare SystemsNotification & MessagingLMS & SIS PlatformsERP WorkflowsReal Estate PlatformsTelemedicine ProductsAPI-first Systems
Technology Focus
Frontend
React • Next.js • TypeScript • Flutter • Tauri
Backend
Go • Gin • gRPC • Django • NestJS • Python • gqlgen
Database
PostgreSQL • Redis • Kafka • MySQL • MongoDB • PostGIS
Infrastructure
Docker • Traefik • Vault • Kubernetes • Linux • Nginx • AWS • Cloudflare • CI/CD • GitHub Actions • OpenTelemetry • Prometheus • Grafana • Loki • Kong
Identity
ORY Kratos • ORY Hydra • ORY Keto • Ory Oathkeeper • OPA
Observability
OpenTelemetry • Prometheus • Grafana • Loki • Elasticsearch • Logstash • Kibana
Selected systems and product case studies by Samuel Kifle
Text-first case studies focused on architecture, outcomes, and maintainability.
Systems & Architecture
Flagship enterprise-grade implementations
Enterprise IAM Platform
Identity-first access architecture built on the ORY ecosystem for enterprise-grade auth.
API Gateway & Authentication Platform
Centralized gateway with RBAC, service routing, and observability-minded backend patterns.
Payment Platform
Central payment orchestration service with DDD architecture, multi-provider routing, ledger, and Ethiopian gateway support.
Notification Gateway
Multi-channel notification service with email, SMS, push, Telegram, and in-app WebSocket delivery.
Healthcare EHR System
Modular EHR architecture with service isolation, clinical workflows, and real-time sync.
Problem
Healthcare teams needed one platform for patient records, coordination, and secure role-based workflows across departments.
Architecture
Microservices-oriented architecture with Next.js frontend, Go and Django backend services, shared auth boundary, and PostgreSQL.
Next.jsGo (Gin)DjangoPostgreSQLRedisFHIRHL7ICD-10
Features
- Patient records and clinical workflow management
- Role-based access and authentication boundaries
- Real-time updates for care-team coordination
Challenges Solved
- Designed service boundaries for patient records, auth, and clinical workflows.
- Implemented real-time communication for care-team coordination.
- Focused on data consistency, scale, and operational reliability.
Users
Clinical teams and operations staff
Response Time
<300ms for core read endpoints
Uptime
Designed for high-availability deployment
Case Study: Problem, Tradeoffs, and Results
Requirements
Support modular healthcare domains, strict access controls, and integration-friendly APIs.
Database Design
Normalized PostgreSQL schemas by healthcare domain with constrained relationships for consistency.
Security Design
Role-isolated service boundaries and secure auth flows across frontend and backend layers.
API Design
REST-first APIs with clean service contracts for patient, clinical, and auth modules.
Tradeoffs
Balanced modularity and delivery speed by splitting critical domains first, then iterating.
Results
Delivered a maintainable healthcare platform architecture that supports feature expansion safely.
Enterprise IAM Platform
Identity-first access architecture built on the ORY ecosystem for enterprise-grade auth.
Problem
Multiple products needed centralized identity, SSO, and fine-grained authorization without duplicating auth logic in every service.
Architecture
Docker-orchestrated Ory stack — Kratos, Hydra, Keto, and Oathkeeper — with Vault-backed secrets, Traefik routing, and dev/prod environment parity.
ORY KratosHydraKetoOathkeeperOPAHashiCorp VaultNext.jsTraefik
Features
- Identity and session management with Kratos
- OAuth2/OIDC flows with Hydra for web, mobile, and M2M clients
- Authorization policy checks with Keto and gateway enforcement via Oathkeeper
Challenges Solved
- Configured multi-environment IAM (dev and production) with helper scripts for OAuth clients and JWKS.
- Integrated gateway-level protection for distributed Senappe services.
- Established reusable IAM patterns for SSO, SPA, mobile, and device authorization flows.
Users
Multi-product engineering teams
Response Time
Low-latency gateway policy checks
Uptime
Enterprise-ready identity architecture
Case Study: Problem, Tradeoffs, and Results
Requirements
Support secure SSO, OAuth2 clients, device flows, and policy decisions across distributed services.
Database Design
Identity and policy storage separated by concern via Ory components on PostgreSQL.
Security Design
Centralized auth and policy enforcement with Oathkeeper gateway validation and Vault-managed secrets.
API Design
Auth endpoints and policy checks abstracted behind service-friendly contracts.
Tradeoffs
Accepted integration complexity to gain consistent identity and authorization guarantees across the platform.
Results
Established the IAM foundation that accounts, admin, payment, and notification services all integrate with.
API Gateway & Authentication Platform
Centralized gateway with RBAC, service routing, and observability-minded backend patterns.
Problem
Backend services required one secure entry point for auth, routing, and service-level controls.
Architecture
Gateway-centric backend architecture in Go and Django with RBAC, route policies, and PostgreSQL.
GoDjangoPostgreSQL
Features
- Centralized request routing and service discovery
- RBAC for internal and external consumers
- Security and observability controls at gateway layer
Challenges Solved
- Built RBAC for internal and external service consumers.
- Improved request routing and service-to-service communication.
- Strengthened security posture for multi-service deployments.
Transactions
High-volume API traffic routing
Response Time
Predictable API latency under load
Uptime
Gateway-oriented reliability improvements
Case Study: Problem, Tradeoffs, and Results
Requirements
Unify authentication, authorization, and request routing for multiple backend services.
Database Design
Policy and identity metadata persisted in PostgreSQL for consistent access checks.
Security Design
RBAC-first policy model and guarded service-to-service communication paths.
API Design
Gateway contracts designed for stable downstream integrations and observability.
Tradeoffs
Introduced gateway dependency to gain stronger control, consistency, and security.
Results
Delivered a centralized API platform that improved backend governance and maintainability.
Payment Platform
Central payment orchestration service with DDD architecture, multi-provider routing, ledger, and Ethiopian gateway support.
Problem
Senappe products needed a single payment boundary — no direct provider access — covering checkout, refunds, wallets, settlements, and marketplace splits.
Architecture
Go microservice with 20 bounded contexts, hexagonal architecture, PostgreSQL + GORM, Redis, Kafka, Temporal workflows, and provider plugins.
GoGingRPCPostgreSQLTemporalKafkaStripeChapaTelebirr
Features
- Hosted checkout sessions, refunds, and idempotent payment APIs
- Double-entry ledger, billing/subscriptions, and marketplace escrow splits
- Provider plugin architecture with circuit breakers and routing failover
Challenges Solved
- Designed 20 bounded contexts with clean service boundaries and transactional outbox patterns.
- Built provider plugins for Stripe, Chapa, Telebirr, CBE, Awash, and internal wallet.
- Integrated Ory (Hydra/Keto) and OPA for zero-trust API authorization.
Transactions
Central payment rail for the Senappe ecosystem
Response Time
Idempotent APIs with routing failover
Uptime
Event-driven reliability with Temporal workflows
Case Study: Problem, Tradeoffs, and Results
Requirements
Single payment gateway for all Senappe apps with ETB/USD support, reconciliation, risk controls, and merchant management.
Database Design
Normalized schemas per bounded context with double-entry ledger tables and audit trails.
Security Design
Zero-trust authorization via Ory Keto and OPA policy evaluation on every request.
API Design
REST and gRPC APIs with idempotency keys, webhooks, and provider-agnostic contracts.
Tradeoffs
Chose DDD complexity upfront to support 20 domains without turning the monolith into unmaintainable spaghetti.
Results
Delivered a production-grade fintech platform tailored to Ethiopian and international payment providers.
Notification Gateway
Multi-channel notification service with email, SMS, push, Telegram, and in-app WebSocket delivery.
Problem
Senappe services needed reliable, templated, multi-channel notifications with scheduling, preferences, and audit — without each app integrating providers directly.
Architecture
Go service with API, Worker, and Scheduler processes; PostgreSQL, Redis, Kafka, Vault-backed provider secrets, and adapter pattern for each channel.
GoGingRPCPostgreSQLKafkaAWS SESFirebase FCMTwilioWebSockets
Features
- Multi-channel delivery: email, SMS, push, Telegram, and in-app WebSocket
- Templates, user preferences, scheduling, and webhook callbacks
- Transactional outbox/inbox pipeline with analytics and audit logging
Challenges Solved
- Built provider adapter pattern with Vault-managed secrets for SES, FCM, Twilio, and Telegram.
- Implemented CQRS delivery pipeline with worker orchestration and retry safeguards.
- Added in-app real-time notifications via WebSocket with OpenTelemetry observability.
Users
All Senappe platform services and end users
Response Time
Async delivery with reliable outbox processing
Uptime
Three-process architecture for API, workers, and scheduling
Case Study: Problem, Tradeoffs, and Results
Requirements
Enterprise notification gateway with templating, channel preferences, scheduling, and delivery analytics.
Database Design
Event-sourced outbox/inbox tables with delivery state tracking per channel.
Security Design
Provider credentials stored in HashiCorp Vault, never in application config.
API Design
gRPC and REST APIs for send, schedule, template management, and webhook ingestion.
Tradeoffs
Separated API, worker, and scheduler processes for independent scaling at the cost of operational complexity.
Results
Shipped a reusable notification backbone that payment and other Senappe services integrate with.
End-user identity portal for login, registration, recovery, and OAuth2 login/consent flows across the Senappe ecosystem.
Problem
Users needed a unified, branded auth experience for Kratos self-service flows and Hydra OAuth2 login/consent without each app building its own UI.
Architecture
Next.js 15 App Router on Cloudflare Workers via OpenNext, integrated with Ory Elements for Kratos and Hydra flows.
Next.jsOry KratosOry HydraCloudflare WorkersTailwind CSS
Features
- Kratos self-service: login, registration, recovery, verification, settings
- Hydra OAuth2 login, consent, logout, and device authorization flows
- Edge-deployed with secure cross-subdomain session handling
Challenges Solved
- Integrated Ory Elements React components with Next.js App Router and server components.
- Deployed auth UI to Cloudflare Workers while connecting to self-hosted Ory backends.
- Handled secure cookie and session boundaries across senappe.com subdomains.
Users
All Senappe end users and OAuth2 client applications
Response Time
Edge-cached static assets with low-latency auth redirects
Uptime
Production auth portal at accounts.senappe.com
Case Study: Problem, Tradeoffs, and Results
Requirements
Branded identity portal supporting all Kratos flows and Hydra OAuth2 for admin, checkout, and future products.
Database Design
Stateless frontend; identity data managed by Ory Kratos and Hydra backends.
Security Design
OAuth2/OIDC consent screens, CSRF protection, and secure session cookies.
API Design
Ory client integration for self-service and OAuth2 challenge/response flows.
Tradeoffs
Chose edge deployment for global latency at the cost of Worker-to-server networking complexity.
Results
Delivered the central auth entry point that all Senappe products redirect to for sign-in.
IAM Admin Dashboard
Internal operations dashboard for managing Kratos identities, Hydra OAuth clients, Keto permissions, and Oathkeeper rules.
Problem
Operations teams needed a secure admin UI to manage the full Ory IAM stack without direct API access or CLI-only workflows.
Architecture
Next.js 15 on Cloudflare Workers with NextAuth v5 (Hydra OIDC), TanStack Query, and server-side API proxies to Ory admin endpoints.
Next.jsNextAuthTanStack QueryOry KratosOry KetoCloudflare Workers
Features
- Kratos identity, session, schema, and courier management
- Hydra OAuth client, key, and discovery configuration
- Keto permission tuples and Oathkeeper gateway rule management
Challenges Solved
- Built API route proxies so the browser never hits Ory admin APIs directly.
- Integrated Hydra OIDC login with email allowlist for operator access control.
- Added health monitoring dashboards for the full IAM stack.
Users
Senappe platform operators and engineering leads
Response Time
Cached queries with real-time admin API proxying
Uptime
Production admin at admin.senappe.com
Case Study: Problem, Tradeoffs, and Results
Requirements
Secure internal dashboard for full Ory stack administration with zero-trust API access patterns.
Database Design
Stateless admin UI; all data managed via Ory service admin APIs.
Security Design
OIDC login via Hydra, server-side API proxying, and operator email allowlist.
API Design
Next.js API routes as secure proxies to Kratos, Hydra, Keto, and Oathkeeper admin APIs.
Tradeoffs
Proxied all admin calls through the Worker to avoid exposing admin URLs to the browser.
Results
Enabled safe, auditable IAM operations without direct backend API exposure.
Session-based checkout UI with multi-provider payment method selection for the Senappe payment platform.
Problem
Merchants and Senappe apps needed a hosted checkout experience supporting Ethiopian and international payment methods.
Architecture
Next.js 15 checkout frontend on Cloudflare Workers with state-driven checkout journeys and payment provider UI components.
Next.jsTailwind CSSFramer MotionCloudflare WorkersChapaTelebirr
Features
- Session-based checkout with customer info, billing, and payment method selection
- Support for wallet, cards, Stripe, PayPal, Chapa, Telebirr, and bank transfer
- Success, processing, and failed state flows with responsive design
Challenges Solved
- Designed multi-step checkout UX with clear state transitions for payment outcomes.
- Built provider-specific payment method UI for Ethiopian gateways (Chapa, Telebirr).
- Deployed checkout UI to Cloudflare Workers for edge performance.
Users
Senappe merchants and end customers
Transactions
Hosted checkout sessions for the payment platform
Response Time
Edge-deployed checkout pages
Case Study: Problem, Tradeoffs, and Results
Requirements
Branded hosted checkout supporting multiple payment providers with clear success/failure flows.
Database Design
Stateless checkout UI; session state managed by the payment platform API.
Security Design
No direct provider credentials in frontend; payment orchestration via backend API.
API Design
Checkout session API integration for payment method selection and status polling.
Tradeoffs
Built provider UI components first, then wired to payment API for incremental delivery.
Results
Delivered a production-ready checkout experience tailored to Ethiopian and international payments.
Public marketing site for Senappe Software — healthcare, PropTech, and enterprise AI/blockchain offerings.
Problem
Senappe needed a professional web presence to showcase services, team, careers, blog, and contact channels.
Architecture
Next.js 15 marketing site on Cloudflare Workers with Framer Motion animations, Recharts, and multi-page SEO structure.
Next.jsFramer MotionTailwind CSSCloudflare WorkersRecharts
Features
- Landing page, services, blog, docs, careers, team, and contact pages
- Animated UI with Framer Motion and responsive component system
- SEO metadata and legal pages for enterprise credibility
Challenges Solved
- Built a multi-page corporate site with consistent branding and animation patterns.
- Deployed to Cloudflare Workers via OpenNext for global edge delivery.
- Structured content for healthcare, PropTech, and enterprise AI service lines.
Users
Prospective clients, partners, and job candidates
Response Time
Edge-cached static pages with fast global delivery
Uptime
Production marketing site at senappe.com
Case Study: Problem, Tradeoffs, and Results
Requirements
Professional corporate presence with service showcases, team profiles, and lead generation.
Database Design
Static content-driven site with no backend database dependency.
Security Design
Public marketing site with standard HTTPS and edge security headers.
API Design
Contact form integration and static content delivery.
Tradeoffs
Prioritized visual polish and SEO over dynamic CMS integration for faster initial launch.
Results
Launched the public face of Senappe Software with enterprise-grade presentation.
Platform Infrastructure
Shared platform infrastructure with Traefik, Vault, Postgres, Redis, and full observability stack for dev and production.
Problem
Senappe services needed shared reverse proxy, secrets management, databases, caching, and observability without each team reinventing ops.
Architecture
Docker Compose multi-network topology with Traefik v3, HashiCorp Vault + Agent, Postgres 16, Redis 7, and Prometheus/Grafana/Loki stack.
DockerTraefikHashiCorp VaultPostgreSQLRedisPrometheusGrafanaLoki
Features
- Reverse proxy with Traefik, ACME TLS via Cloudflare DNS, and service routing
- Vault KV secrets and dynamic PostgreSQL credentials via Vault Agent
- Full observability: Prometheus metrics, Grafana dashboards, Loki logs, Alertmanager
Challenges Solved
- Designed multi-network Docker topology separating public, internal, and database networks.
- Configured Vault Agent to render dynamic DB credentials and static secrets for IAM services.
- Set up GitHub Actions CI/CD pipelines for build and deploy workflows.
Response Time
Centralized routing and caching for service mesh
Uptime
Platform backbone for all Senappe self-hosted services
Case Study: Problem, Tradeoffs, and Results
Requirements
Shared infrastructure for local dev parity with production, including secrets, DB, cache, and monitoring.
Database Design
Centralized PostgreSQL with Vault-managed dynamic credentials per service.
Security Design
Vault-backed secrets, network isolation, and TLS termination at Traefik.
API Design
Traefik routing labels for service discovery and gateway configuration.
Tradeoffs
Chose Docker Compose over Kubernetes for team size and operational simplicity at current scale.
Results
Delivered the platform foundation that IAM, payment, and notification services all run on.
AI-powered recommendation assisted system with chatbot-assisted discovery.
Problem
Users needed relevant recommendations from large, noisy datasets with minimal manual filtering.
Architecture
Django + React recommendation platform with NLP services and API-integrated conversational flow.
Django DRFPostgreSQLRedisReactTailwind CSSTypeScriptOpenAINLP
Features
- Recommendation workflows informed by NLP signals
- Chatbot interface for guided discovery
- Backend APIs for recommendation delivery
Challenges Solved
- Built recommendation logic tailored to domain-specific user intent.
- Integrated chatbot interactions with backend APIs.
Users
Property and product discovery users
Response Time
Fast recommendation retrieval from ranked candidates
Case Study: Problem, Tradeoffs, and Results
Requirements
Deliver contextual recommendations with conversational interaction and scalable backend APIs.
Database Design
Structured records indexed for recommendation relevance and retrieval performance.
Security Design
Protected user sessions and request validation across chatbot endpoints.
API Design
Recommendation and conversational APIs separated for cleaner service ownership.
Tradeoffs
Balanced recommendation precision against response latency for better UX.
Results
Improved relevance and engagement through AI-assisted recommendation workflows.
Multi-Vendor E-Commerce Platform
Marketplace system with auth, admin tooling, and payment-integrated workflows.
Problem
Vendors and customers required a single platform for catalog, checkout, and operational management.
Architecture
React + Django marketplace with role-aware modules and centralized data management.
ReactDjangoPostgreSQL
Features
- Vendor onboarding and catalog management
- Customer checkout and order workflows
- Admin moderation and reporting tools
Challenges Solved
- Delivered vendor, customer, and admin flows in a single platform.
- Implemented secure authentication and role-based management.
Users
Multi-role marketplace participants
Transactions
Order and payment flow handling
Case Study: Problem, Tradeoffs, and Results
Requirements
Support role-specific experiences for vendors, customers, and platform operators.
Database Design
Transactional schema for products, orders, and role-linked permissions.
Security Design
Role-based authorization and secure session handling.
API Design
Modular API endpoints aligned to catalog, order, and admin contexts.
Tradeoffs
Prioritized core marketplace operations before advanced personalization features.
Results
Shipped a full-stack commerce platform with clear operational boundaries.
Community finance platform digitizing traditional contribution and event coordination flows.
Problem
Community fundraising operations were manual, error-prone, and lacked transparent tracking.
Architecture
Next.js + Django + WebSocket stack for real-time contribution and membership coordination.
Next.jsDjangoWebSocket
Features
- Real-time contribution tracking
- Member coordination workflows
- Event and payment management modules
Challenges Solved
- Built real-time contribution tracking and member coordination.
- Modeled event and payment operations for community workflows.
Users
Community members and coordinators
Transactions
Recurring contribution and event workflows
Case Study: Problem, Tradeoffs, and Results
Requirements
Digitize recurring fundraising processes with trustworthy, transparent records.
Database Design
Member, contribution, and event entities with auditable relationships.
Security Design
Role-aware permissions for coordinators and participants.
API Design
Realtime + REST blend for live updates and transactional actions.
Tradeoffs
Chose pragmatic event model before introducing fully event-driven backend.
Results
Enabled transparent community finance operations in a modern web workflow.
Policy and claims platform designed for secure role-based operational workflows.
Problem
Insurance teams needed digital workflows for policy lifecycle, claims, and customer operations.
Architecture
Next.js + Django full-stack architecture with RBAC-secured REST APIs and document workflows.
Next.jsDjangoREST APIRBAC
Features
- Policy lifecycle management
- Claims intake and processing
- Role-based customer and operator interfaces
Challenges Solved
- Implemented policy lifecycle and claims-processing backend services.
- Designed scalable document and customer-management flow.
Users
Insurance operations and customer support teams
Response Time
Consistent service latency for policy and claim APIs
Case Study: Problem, Tradeoffs, and Results
Requirements
Digitize insurance operations with secure role boundaries and scalable data workflows.
Database Design
Domain schema for policy, claims, and customer records with traceability.
Security Design
RBAC enforcement and protected policy operations.
API Design
Service-oriented REST APIs for policy lifecycle and claims processing.
Tradeoffs
Focused on operational reliability first, then planned advanced automation features.
Results
Delivered an enterprise-ready base for insurance workflow digitization.
Scalable messaging product with event-driven communication over WebSockets.
Problem
Users required low-latency, reliable messaging with state synchronization across clients.
Architecture
Next.js frontend with Socket.IO-powered real-time backend messaging services.
Next.jsSocket.IO
Features
- Live bidirectional messaging
- Event-driven updates for participants
- Scalable room/channel communication model
Challenges Solved
- Built event-driven messaging flows for live user interaction.
- Optimized frontend rendering and message delivery handling.
Users
Concurrent real-time chat participants
Response Time
Near real-time message delivery
Case Study: Problem, Tradeoffs, and Results
Requirements
Provide stable real-time communication with responsive UX under concurrent usage.
Database Design
Message persistence designed for retrieval and chronological consistency.
Security Design
Session-bound channels and validated event payload patterns.
API Design
Event contract design for predictable client-server synchronization.
Tradeoffs
Balanced persistence complexity with realtime responsiveness for MVP delivery.
Results
Delivered a responsive messaging system with reliable real-time interaction patterns.
Decentralized Voting System
Tamper-resistant smart contract voting workflow for transparent election logic.
Problem
Voting processes required transparent and tamper-resistant counting and verification.
Architecture
Solidity-based on-chain voting contracts with web integration for voter interaction.
SolidityWeb3
Features
- Immutable on-chain vote records
- Transparent tally process
- Smart-contract enforced workflow rules
Challenges Solved
- Designed immutable vote and tally lifecycle in smart contracts.
- Focused on verifiability and integrity guarantees.
Users
Election participants and auditors
Transactions
On-chain vote submissions
Case Study: Problem, Tradeoffs, and Results
Requirements
Guarantee vote integrity and transparent counting through verifiable contract logic.
Database Design
On-chain storage strategy with optimized contract state for vote lifecycle handling.
Security Design
Smart contract guardrails against invalid vote and tally states.
API Design
Client-contract integration patterns for secure vote submissions.
Tradeoffs
Accepted blockchain transaction overhead to gain stronger integrity guarantees.
Results
Implemented a verifiable voting workflow with tamper-resistant contract execution.
System design gallery
Representative architecture patterns for SaaS, healthcare, identity, and distributed backend systems.
Multi-Tenant SaaS Architecture
Shared platform with tenant-isolated data and role-aware access patterns.
Architecture Patterns
- Tenant-aware RBAC
- Schema partitioning strategy
- Request-scoped tenant context
Engineering Impact
- Supports enterprise tenant boundaries
- Designed for maintainable feature growth
Healthcare Platform Design
Domain-oriented architecture for patient records, workflows, and auditability.
Architecture Patterns
- Service boundaries by healthcare domain
- Strong consistency models
- Secure data flows
Engineering Impact
- Built for sensitive data handling
- Prioritizes operational reliability
OIDC / OAuth2 Identity Flow
Identity-first authentication and authorization platform with ORY stack.
Architecture Patterns
- Kratos + Hydra + Keto + Oathkeeper
- Gateway policy enforcement
- Token lifecycle control
Engineering Impact
- Centralized identity governance
- Reusable auth architecture
Event-Driven Backend Communication
Asynchronous workflow coordination for real-time and distributed systems.
Architecture Patterns
- Domain event contracts
- Eventually consistent processing
- Retry and idempotency safeguards
Engineering Impact
- Improves resilience under load
- Decouples dependent services
Caching and API Performance Strategy
Layered caching and query optimization for API-heavy systems.
Architecture Patterns
- Read-through caching
- Hot-path query indexing
- Latency-aware endpoint design
Engineering Impact
- Faster endpoint response times
- Lower backend load
API Gateway Architecture
Centralized routing, auth, and policy controls for service ecosystems.
Architecture Patterns
- Gateway-level RBAC
- Route-level controls
- Observability hooks
Engineering Impact
- Improved security posture
- Consistent API governance
Payment Orchestration (DDD)
Senappe payment platform with 20 bounded contexts, provider plugins, and ledger accounting.
Architecture Patterns
- Hexagonal architecture with provider adapters
- Transactional outbox for event reliability
- Circuit breakers and routing failover
Engineering Impact
- Single payment boundary for all Senappe apps
- Ethiopian gateway support (Chapa, Telebirr, ETB)
Multi-Channel Notification Pipeline
Senappe notification gateway with async delivery across email, SMS, push, and WebSocket.
Architecture Patterns
- CQRS with outbox/inbox pattern
- Vault-backed provider secrets
- API / Worker / Scheduler process split
Engineering Impact
- Decoupled channel delivery from business services
- Reliable async processing with retry safeguards
Edge-Deployed Frontends
Senappe web apps deployed on Cloudflare Workers via OpenNext for global low-latency delivery.
Architecture Patterns
- OpenNext + Wrangler deployment pipeline
- Server components with edge runtime
- Secure cross-subdomain session handling
Engineering Impact
- Auth, admin, checkout, and marketing on the edge
- Connects to self-hosted Ory and Go backends
Professional timeline, education, and certifications
Career progression and leadership milestones relevant to software engineering roles.
Aug 2025 - PresentAddis Ababa, Ethiopia
Full-Stack Developer
Tilla Health
Designed and delivered production features in Next.js and Django for healthcare workflows, integrating APIs that support reliable real-time user operations.
Jun 2024 - PresentAddis Ababa, Ethiopia
Software Engineer
Senappe Software
Lead architecture and development of Softwares and architected the full platform ecosystem — Ory IAM stack, payment orchestration, notification gateway, edge-deployed frontends (accounts, admin, checkout), and shared infrastructure with Vault, Traefik, and observability.
Jan 2024 - Jun 2024Addis Ababa, Ethiopia
Backend Developer Intern
Perago Information Systems
Developed NestJS backend services, authored API contracts, and improved backend reliability through simulation-driven API testing workflows.
Sep 2023 - Dec 2023Addis Ababa, Ethiopia
Frontend Developer Intern
Addisway Technology Solutions
Built responsive React interfaces, integrated REST APIs, and improved client-facing performance and mobile usability.
2019 - 2024Debre Birhan, Ethiopia
Electronics & Software Technician
YAS Electronics
Diagnosed and resolved hardware/software failures for 100+ clients, including OS maintenance, firmware patching, and enterprise tooling setup.
Technical depth across backend, platform, and product engineering
Focused on production architecture, API systems, and maintainable delivery.
Go, backend engineering, distributed systems, cloud architecture, Kubernetes, microservices, platform engineering, AI, and full-stack development — with Next.js, Django, PostgreSQL, Docker, and the Ory IAM stack for production delivery.
Frontend
React · Next.js · TypeScript · TanStack Query · TanStack Form · TanStack Router · TanStack Table · TanStack Pagination · Zustand · React Hook Form · Zod · Tailwind CSS · Shadcn UI · Radix UI · Framer Motion
Backend & APIs
Go · Gin · gRPC · GORM · Django · Django REST · NestJS · GraphQL · WebSockets · Temporal
Data & messaging
PostgreSQL · Redis · Kafka · PostGIS · MySQL · MongoDB
Platform & infra
Docker · Traefik · HashiCorp Vault · Cloudflare Workers · OpenNext · Kubernetes · Linux · Nginx · AWS · Cloudflare · CI/CD · GitHub Actions · OpenTelemetry · Prometheus · Grafana · Loki
Identity & security
OAuth2 · OIDC · JWT · ORY Kratos · ORY Hydra · ORY Keto · Oathkeeper · RBAC · ABAC · OPA
Architecture & distributed systems
Domain-Driven Design · Microservices architecture · CQRS & Event Sourcing · Clean Architecture · Hexagonal architecture · Event-driven systems · Transactional outbox · Circuit breakers · LLM APIs · RAG
Let us build something reliable together.
Reach out to Samuel Kifle for collaboration, hiring conversations, or architecture consultations.
Address
Addis Ababa, Ethiopia