I have been learning Python since early 2017. Having studied many books and video courses and built a variety of projects using the skills learned, I have used Python for scripting, web development and data analysis/visualisation tool.

I have used a variety of libraries within the Python and Anaconda ecosystem and have an extensive knowledge of the extended standard library. Amongst many others, I have a good working knowledge of libraries such as itertools, functools, decorators, and collections.

Although the need for some of the tools within these libraries is not always required, it's useful to know for when you would like to build more efficient code or a standard data structure just doesn't give you the required functionality.

There are also examples of using these non-standard data structures within the Countdown Letters and Countdown Numbers apps.

I also have a good working knowledge of some of Python's common libraries such as Requests, Beautiful Soup and Selenium

Having developed several projects in Django including the whole of the portfolio that you're currently reviewing, I have developed significant skills with it.

Although nowadays I have starter projects to kickstart quickly, I can efficiently build a site from scratch using Django and overcome many of the obstacles in Django that the community considers to be advanced usage. Examples include:

• Creation of a custom authentication system subclassing from either AbstractUser or AbstractBaseUser.
• Use and configure Django-allauth which is the de facto standard for any projects that uses something other than Django’s default username/password authentication pattern.
• The use of Celery/Redis to run many complex automated scheduled tasks.
• Know the class-based views API extremely well including the use of higher-level classes to abstract logic for subsequent child views. In my opinion, this makes the views more reusable and extensible. Included within this, I also know how to include multiple forms per web page or process multiple forms within a single class based view. I understand advanced concepts such as inheritance including multiple inheritance and MRO.
• Advanced configuration of Django models including the use of constraints, metadata, managers, instance and class methods.
• Advanced form design and features such as front-end JavaScript validation feedback in addition to server-side checks and message rendering. Building of forms using ordinary Django forms, Crispy Forms, Django Widget Tweaks, or integrating raw Boostrap HTML.
• Efficient querying of the database using the ORM. This includes setting up model managers throughout the project to retrieve related objects efficiently and reuse common querysets throughout.
• Creation of custom mixins to simplify views logic with repitition.
• Creation of custom Django management commands.
• Consume an external API or scrape content from the web and store that data within the database. If necessary, also cleaning and manipulating the data.
• Set up and use context processors for global context variables saving the get_context_data method from being overridden many times.
• Build a highly customised admin interface that could essentially be a fast prototype of an application. This includes amendments to widget sizes, an overridden HTML template and CSS amendments.

I have built multiple production-grade applications using FastAPI including an event and ticketing platform, a telehealth API-driven system, and other high-performance backend services. My focus with FastAPI is clean architecture, performance, and long-term maintainability.

My FastAPI expertise includes:

• Designing scalable RESTful APIs with proper routing structure, dependency injection, and modular application layout.
• Implementing robust authentication and authorization using JWT, OAuth2, role-based access control, and secure token management.
• Advanced Pydantic schema design for strict request and response validation, data transformation, and serialization control.
• Asynchronous programming using async and await for high-concurrency systems, including integration with external APIs and third-party services.
• Database integration using SQLAlchemy and PostgreSQL with proper session management, optimized queries, indexing strategy, and transaction handling.
• Background task processing and job queues using Celery and Redis for scheduled jobs, notifications, and long-running processes.
• API documentation and schema customization using OpenAPI and Swagger, ensuring clean and developer-friendly interfaces.
• Integration with payment gateways, messaging services, and third-party healthcare systems.
• Writing structured middleware for logging, monitoring, error handling, and request lifecycle control.
• Containerization and deployment-ready configuration using Docker, environment-based settings management, and production tuning.

I approach FastAPI projects with a strong emphasis on architecture. The goal is not just to deliver endpoints, but to build systems that can scale cleanly as traffic and complexity increase.

I design and implement GraphQL APIs for scalable, data-intensive applications, enabling clients to request precisely the data they need while maintaining strong architectural boundaries and performance discipline.

My GraphQL expertise includes:

• Designing well-structured schemas with clear type definitions, relationships, and domain-driven modeling.
• Implementing queries, mutations, and subscriptions with clean, maintainable resolver logic.
• Efficient database interaction using batching techniques and query optimization strategies to prevent N+1 problems.
• Role-based authorization and field-level access control to enforce security across complex schemas.
• Integration with Python backends using FastAPI and asynchronous execution for high concurrency environments.
• Schema evolution and versioning strategies that support long-term product growth without breaking clients.
• Real-time capabilities using subscriptions for event-driven systems.
• API performance monitoring, complexity analysis, and query depth limiting to maintain stability at scale.

I approach GraphQL as an architectural layer, not just a query language. The objective is to create a flexible yet controlled data contract that scales cleanly as application complexity grows.

I have used pytest exclusively as my testing framework of choice. I see very little reason to be using Python's built-in testing framework since the pytest API, community, and plugin ecosystem is so good.

In addition to standard pytest, I have a good working knowledge of pytest-django, coverage, some mocking libraries such as factoryboy and mixer, and an evolving knowledge of hypothesis.

I would love to improve my knowledge of hypothesis more as I can see how extremely powerful it can be.

Within this portfolio project, you can see many examples of testing of models, views, urls, and forms. Somewhat controversially, I also test the project's settings. To me, this seems like a sensible thing to do, although I appreciate many others disagree.

If you, or someone else on the team, changes a project setting which is imperative for the project to function correctly, they may not be aware of the breaking change. It might not even show up in the running of an extensive test suite. Some of the project's settings are in place for the front-end to function correctly. If there is a failing test for a setting, it at least prompts the question, "are you sure this project will continue to function as expected by changing this setting?" If the programmer is sure, they can always just change the test.

In addition, and certainly where I have control of an external site's 404 breakages, I test links to external websites. I learned this after a large restructuring exercise where I grouped apps into an 'apps' directory and ended up breaking a lot of the external links which should have enabled the user to navigate to the relevant source code page.

PostgreSQL is my primary database engine for production systems. My background in database design goes beyond ORM usage. I focus on schema structure, indexing strategy, query performance, and long term data integrity.

My PostgreSQL expertise includes:

• Designing normalized and performance oriented schemas with proper constraints, foreign keys, indexing, and transactional integrity.
• Query optimization using execution plan analysis, composite indexes, partial indexes, and advanced SQL constructs.
• Implementing full text search using native PostgreSQL search vectors and ranking strategies.
• Building and managing multi tenant architectures with secure data isolation and role based access control.
• Working with PostGIS for geospatial data modeling, spatial indexing, and location based queries.
• Database migration planning, troubleshooting schema conflicts, and direct inspection using CLI tools and database clients.
• Docker based database provisioning with secure environment configuration for development, testing, and production environments.

I approach database design as a foundational engineering discipline. A well structured database reduces application complexity, improves performance, and enables systems to scale predictably.